From 3c46e3b1489d9a07750fd7b1c994f39a66c74e08 Mon Sep 17 00:00:00 2001 From: Daniel Bittman Date: Thu, 9 Jan 2025 16:51:50 -0800 Subject: [PATCH] Adjust tracing levels. --- src/kernel/src/pager/queues.rs | 51 +++++++------- src/kernel/src/queue.rs | 1 - src/srv/pager-srv/object-store/src/disk.rs | 23 +++---- .../object-store/src/nvme/controller.rs | 2 + .../object-store/src/object_store.rs | 2 +- src/srv/pager-srv/src/data.rs | 54 +++++++-------- src/srv/pager-srv/src/helpers.rs | 2 +- src/srv/pager-srv/src/lib.rs | 68 +++++++------------ src/srv/pager-srv/src/request_handle.rs | 21 +++--- 9 files changed, 98 insertions(+), 126 deletions(-) diff --git a/src/kernel/src/pager/queues.rs b/src/kernel/src/pager/queues.rs index a512b983..44016163 100644 --- a/src/kernel/src/pager/queues.rs +++ b/src/kernel/src/pager/queues.rs @@ -71,7 +71,6 @@ fn pager_request_copy_user_phys( fn pager_test_request() -> CompletionToPager { let sender = SENDER.wait(); let obj_id = ObjID::new(1001); - logln!("kernel: submitting page data request on K2P Queue"); let item = RequestFromKernel::new(twizzler_abi::pager::KernelCommand::PageDataReq( obj_id, ObjectRange { @@ -82,7 +81,6 @@ fn pager_test_request() -> CompletionToPager { let id = sender.0.next_simple().value() as u32; let res = SENDER.wait().1.submit(item, id); - logln!("kernel: submitting obj info request on K2P Queue"); let item = RequestFromKernel::new(twizzler_abi::pager::KernelCommand::ObjectInfoReq(obj_id)); let id = sender.0.next_simple().value() as u32; let res = SENDER.wait().1.submit(item, id); @@ -93,30 +91,27 @@ fn pager_test_request() -> CompletionToPager { pub(super) fn pager_request_handler_main() { let receiver = RECEIVER.wait(); loop { - receiver.handle_request(|id, req| { - logln!("kernel: got req {}:{:?} from pager", id, req); - match req.cmd() { - PagerRequest::EchoReq => { - CompletionToPager::new(twizzler_abi::pager::PagerCompletionData::EchoResp) - } - PagerRequest::TestReq => pager_test_request(), - PagerRequest::Ready => { - let reg = PAGER_MEMORY - .poll() - .map(|pm| (pm.start.raw(), pm.length)) - .unwrap_or((0, 0)); - CompletionToPager::new(twizzler_abi::pager::PagerCompletionData::DramPages( - PhysRange::new(reg.0, reg.0 + reg.1 as u64), - )) - } - PagerRequest::CopyUserPhys { - target_object, - offset, - len, - phys, - write_phys, - } => pager_request_copy_user_phys(target_object, offset, len, phys, write_phys), + receiver.handle_request(|id, req| match req.cmd() { + PagerRequest::EchoReq => { + CompletionToPager::new(twizzler_abi::pager::PagerCompletionData::EchoResp) } + PagerRequest::TestReq => pager_test_request(), + PagerRequest::Ready => { + let reg = PAGER_MEMORY + .poll() + .map(|pm| (pm.start.raw(), pm.length)) + .unwrap_or((0, 0)); + CompletionToPager::new(twizzler_abi::pager::PagerCompletionData::DramPages( + PhysRange::new(reg.0, reg.0 + reg.1 as u64), + )) + } + PagerRequest::CopyUserPhys { + target_object, + offset, + len, + phys, + write_phys, + } => pager_request_copy_user_phys(target_object, offset, len, phys, write_phys), }); } } @@ -127,13 +122,13 @@ pub(super) fn pager_compl_handler_main() { let completion = sender.1.recv_completion(); match completion.1.data() { twizzler_abi::pager::KernelCompletionData::EchoResp => { - logln!("got echo response"); + //logln!("got echo response"); } twizzler_abi::pager::KernelCompletionData::PageDataCompletion(phys_range) => { - logln!("got physical range {:?}", phys_range); + //logln!("got physical range {:?}", phys_range); } twizzler_abi::pager::KernelCompletionData::ObjectInfoCompletion(obj_info) => { - logln!("got object info {:?}", obj_info); + //logln!("got object info {:?}", obj_info); } } sender.0.release_simple(SimpleId::from(completion.0)); diff --git a/src/kernel/src/queue.rs b/src/kernel/src/queue.rs index 9eba8573..c797443b 100644 --- a/src/kernel/src/queue.rs +++ b/src/kernel/src/queue.rs @@ -154,7 +154,6 @@ impl QueueObject { } pub fn complete(&self, item: C, info: u32) { - logln!("kernel: completing!! {}", info); self.completions.send(item, info) } diff --git a/src/srv/pager-srv/object-store/src/disk.rs b/src/srv/pager-srv/object-store/src/disk.rs index 9f8c6c24..018148ec 100644 --- a/src/srv/pager-srv/object-store/src/disk.rs +++ b/src/srv/pager-srv/object-store/src/disk.rs @@ -1,13 +1,9 @@ use std::{ - borrow::BorrowMut, - io::{self, Error, ErrorKind}, - ops::Deref, - sync::{Arc, LazyLock, Mutex, OnceLock}, + io::{Error, ErrorKind}, + sync::{Arc, LazyLock, Mutex}, }; -use fatfs::{ - FatType, FileSystem, FormatVolumeOptions, IntoStorage, IoBase, Read, Seek, SeekFrom, Write, -}; +use fatfs::{FatType, FileSystem, FormatVolumeOptions, IoBase, Read, Seek, SeekFrom}; use twizzler_async::block_on; use crate::nvme::{init_nvme, NvmeController}; @@ -26,9 +22,8 @@ impl Disk { } } -static DISK: OnceLock = OnceLock::new(); pub static FS: LazyLock>> = LazyLock::new(|| { - let mut disk = Disk::new().unwrap(); + let disk = Disk::new().unwrap(); let fs_options = fatfs::FsOptions::new().update_accessed_date(false); let fs = FileSystem::new(disk, fs_options); if let Ok(fs) = fs { @@ -78,7 +73,7 @@ impl fatfs::Read for Disk { } else { left + buf.len() - bytes_written }; // If I want to write more than the boundary of a page - block_on(self.ctrl.read_page(lba as u64, &mut read_buffer, 0)); + block_on(self.ctrl.read_page(lba as u64, &mut read_buffer, 0)).unwrap(); let bytes_to_read = right - left; buf[bytes_written..bytes_written + bytes_to_read] @@ -112,9 +107,10 @@ impl fatfs::Write for Disk { }; if right - left != PAGE_SIZE { let temp_pos: u64 = self.pos.try_into().unwrap(); - self.seek(SeekFrom::Start(temp_pos & !PAGE_MASK as u64)); + self.seek(SeekFrom::Start(temp_pos & !PAGE_MASK as u64)) + .unwrap(); self.read_exact(&mut write_buffer)?; - self.seek(SeekFrom::Start(temp_pos)); + self.seek(SeekFrom::Start(temp_pos)).unwrap(); } write_buffer[left..right].copy_from_slice(&buf[bytes_read..bytes_read + right - left]); @@ -122,7 +118,7 @@ impl fatfs::Write for Disk { self.pos += right - left; - block_on(self.ctrl.write_page(lba as u64, &mut write_buffer, 0)); + block_on(self.ctrl.write_page(lba as u64, &mut write_buffer, 0)).unwrap(); lba += PAGE_SIZE / SECTOR_SIZE; } @@ -142,7 +138,6 @@ impl fatfs::Seek for Disk { SeekFrom::Current(x) => (self.pos as i64) + x, }; if new_pos > DISK_SIZE.try_into().unwrap() || new_pos < 0 { - println!("HERE!"); Err(Error::new(ErrorKind::AddrInUse, "oh no!")) } else { self.pos = new_pos as usize; diff --git a/src/srv/pager-srv/object-store/src/nvme/controller.rs b/src/srv/pager-srv/object-store/src/nvme/controller.rs index 1472d905..dc896283 100644 --- a/src/srv/pager-srv/object-store/src/nvme/controller.rs +++ b/src/srv/pager-srv/object-store/src/nvme/controller.rs @@ -27,6 +27,7 @@ use volatile::map_field; use super::{dma::NvmeDmaRegion, requester::NvmeRequester}; use crate::nvme::dma::NvmeDmaSliceRegion; +#[allow(dead_code)] pub struct NvmeController { requester: RwLock>>, admin_requester: RwLock>>>, @@ -439,6 +440,7 @@ impl NvmeController { ident.dma_region().with(|ident| ident.clone()) } + #[allow(dead_code)] pub async fn flash_len(&self) -> usize { if let Some(sz) = self.capacity.get() { *sz diff --git a/src/srv/pager-srv/object-store/src/object_store.rs b/src/srv/pager-srv/object-store/src/object_store.rs index f5c7a28f..b910a198 100644 --- a/src/srv/pager-srv/object-store/src/object_store.rs +++ b/src/srv/pager-srv/object-store/src/object_store.rs @@ -39,7 +39,7 @@ pub fn create_object(obj_id: u128) -> Result { Ok(_) => Ok(false), Err(e) => match e { fatfs::Error::NotFound => { - subdir.create_file(&b64); + subdir.create_file(&b64).unwrap(); Ok(true) } _ => Err(e.into()), diff --git a/src/srv/pager-srv/src/data.rs b/src/srv/pager-srv/src/data.rs index 5cf2ce66..385e976c 100644 --- a/src/srv/pager-srv/src/data.rs +++ b/src/srv/pager-srv/src/data.rs @@ -5,7 +5,7 @@ use std::{ use bitvec::prelude::*; use twizzler_abi::pager::{ObjectRange, PhysRange}; -use twizzler_object::{ObjID, Object, ObjectInitFlags, Protections}; +use twizzler_object::ObjID; use crate::helpers::{page_in, page_to_physrange}; @@ -25,7 +25,7 @@ impl PagerDataInner { /// Create a new PagerDataInner instance /// Initializes the data structure for managing page allocations and replacements. pub fn new() -> Self { - tracing::info!("initializing PagerDataInner"); + tracing::trace!("initializing PagerDataInner"); PagerDataInner { bitvec: BitVec::new(), hashmap: HashMap::with_capacity(0), @@ -42,16 +42,16 @@ impl PagerDataInner { /// Get the next available page number and mark it as used. /// Returns the page number if available, or `None` if all pages are used. fn get_next_available_page(&mut self) -> Option { - tracing::info!("searching for next available page"); + tracing::trace!("searching for next available page"); let next_page = self.bitvec.iter().position(|bit| !bit); if let Some(page_number) = next_page { self.bitvec.set(page_number, true); self.lru_queue.push_back(page_number.try_into().unwrap()); - tracing::info!("next available page: {}", page_number); + tracing::trace!("next available page: {}", page_number); Some(page_number) } else { - tracing::info!("no available pages left"); + tracing::debug!("no available pages left"); None } } @@ -59,9 +59,9 @@ impl PagerDataInner { /// Perform page replacement using the Least Recently Used (LRU) strategy. /// Returns the identifier of the replaced page. fn page_replacement(&mut self) -> u64 { - tracing::info!("executing page replacement"); + tracing::debug!("executing page replacement"); if let Some(old_page) = self.lru_queue.pop_front() { - tracing::info!("replacing page: {}", old_page); + tracing::trace!("replacing page: {}", old_page); self.remove_page(old_page as usize); old_page } else { @@ -72,9 +72,9 @@ impl PagerDataInner { /// Get a memory page for allocation. /// Triggers page replacement if all pages are used. fn get_mem_page(&mut self) -> usize { - tracing::info!("attempting to get memory page"); + tracing::debug!("attempting to get memory page"); if self.bitvec.all() { - tracing::info!("all pages used, initiating page replacement"); + tracing::trace!("all pages used, initiating page replacement"); self.page_replacement(); } self.get_next_available_page().expect("no available pages") @@ -82,14 +82,14 @@ impl PagerDataInner { /// Remove a page from the bit vector, freeing it for future use. fn remove_page(&mut self, page_number: usize) { - tracing::info!("attempting to remove page {}", page_number); + tracing::debug!("attempting to remove page {}", page_number); if page_number < self.bitvec.len() { self.bitvec.set(page_number, false); self.remove_from_map(&(page_number as u64)); self.lru_queue.retain(|&p| p != page_number as u64); - tracing::info!("page {} removed from bitvec", page_number); + tracing::trace!("page {} removed from bitvec", page_number); } else { - tracing::info!( + tracing::warn!( "page {} is out of bounds and cannot be removed", page_number ); @@ -98,33 +98,33 @@ impl PagerDataInner { /// Resize the bit vector to accommodate more pages or clear it. fn resize_bitset(&mut self, new_size: usize) { - tracing::info!("resizing bitvec to new size: {}", new_size); + tracing::debug!("resizing bitvec to new size: {}", new_size); if new_size == 0 { - tracing::info!("clearing bitvec"); + tracing::trace!("clearing bitvec"); self.bitvec.clear(); } else { self.bitvec.resize(new_size, false); } - tracing::info!("bitvec resized to: {}", new_size); + tracing::trace!("bitvec resized to: {}", new_size); } /// Check if all pages are currently in use. pub fn is_full(&self) -> bool { let full = self.bitvec.all(); - tracing::info!("bitvec check full: {}", full); + tracing::trace!("bitvec check full: {}", full); full } /// Insert an object and its associated range into the hashmap. pub fn insert_into_map(&mut self, key: u64, obj_id: ObjID, range: ObjectRange) { - tracing::info!( + tracing::trace!( "inserting into hashmap: key = {}, ObjID = {:?}, ObjectRange = {:?}", key, obj_id, range ); self.hashmap.insert(key, (obj_id.clone(), range.clone())); - tracing::info!( + tracing::trace!( "inserted into hashmap: key = {}, ObjID = {:?}, ObjectRange = {:?}", key, obj_id, @@ -141,16 +141,16 @@ impl PagerDataInner { /// Retrieve an object and its range from the hashmap by key. /// Updates the LRU queue to reflect access. pub fn get_from_map(&mut self, key: &u64) -> Option<(ObjID, ObjectRange)> { - tracing::info!("retrieving value for key {}", key); + tracing::trace!("retrieving value for key {}", key); match self.hashmap.get(key) { Some(value) => { - tracing::info!("value found for key {}: {:?}", key, value); + tracing::trace!("value found for key {}: {:?}", key, value); self.lru_queue.retain(|&p| p != *key); self.lru_queue.push_back(*key); Some(value.clone()) } None => { - tracing::info!("no value found for key: {}", key); + tracing::trace!("no value found for key: {}", key); None } } @@ -158,13 +158,13 @@ impl PagerDataInner { /// Remove a key and its associated value from the hashmap. pub fn remove_from_map(&mut self, key: &u64) { - tracing::info!("removing key {} from hashmap", key); + tracing::trace!("removing key {} from hashmap", key); self.hashmap.remove(key); } /// Reserve additional capacity in the hashmap. pub fn resize_map(&mut self, add_size: usize) { - tracing::info!("adding {} capacity to hashmap", add_size); + tracing::trace!("adding {} capacity to hashmap", add_size); self.hashmap.reserve(add_size); } } @@ -173,7 +173,7 @@ impl PagerData { /// Create a new PagerData instance. /// Wraps PagerDataInner with thread-safe access. pub fn new() -> Self { - tracing::info!("creating new PagerData instance"); + tracing::trace!("creating new PagerData instance"); PagerData { inner: Arc::new(Mutex::new(PagerDataInner::new())), } @@ -181,7 +181,7 @@ impl PagerData { /// Resize the internal structures to accommodate the given number of pages. pub fn resize(&self, pages: usize) { - tracing::info!("resizing resources to support {} pages", pages); + tracing::debug!("resizing resources to support {} pages", pages); let mut inner = self.inner.lock().unwrap(); inner.resize_bitset(pages); inner.resize_map(pages); @@ -196,7 +196,7 @@ impl PagerData { /// Page in the data from disk /// Returns the physical range corresponding to the allocated page. pub fn fill_mem_page(&self, id: ObjID, obj_range: ObjectRange) -> PhysRange { - tracing::info!( + tracing::debug!( "allocating memory page for ObjID {:?}, ObjectRange {:?}", id, obj_range @@ -206,7 +206,7 @@ impl PagerData { inner.insert_into_map(page.try_into().unwrap(), id, obj_range); let phys_range = page_to_physrange(page, 0); page_in(id, obj_range, phys_range); - tracing::info!("memory page allocated successfully"); + tracing::trace!("memory page allocated successfully"); return phys_range; } } diff --git a/src/srv/pager-srv/src/helpers.rs b/src/srv/pager-srv/src/helpers.rs index 45026125..f1fa1619 100644 --- a/src/srv/pager-srv/src/helpers.rs +++ b/src/srv/pager-srv/src/helpers.rs @@ -1,5 +1,5 @@ use twizzler_abi::pager::{ObjectRange, PhysRange}; -use twizzler_object::{ObjID, Object, ObjectInitFlags, Protections}; +use twizzler_object::ObjID; /// A constant representing the page size (4096 bytes per page). pub const PAGE: u64 = 4096; diff --git a/src/srv/pager-srv/src/lib.rs b/src/srv/pager-srv/src/lib.rs index 6430ec6d..8ad60c42 100644 --- a/src/srv/pager-srv/src/lib.rs +++ b/src/srv/pager-srv/src/lib.rs @@ -2,31 +2,20 @@ #![feature(naked_functions)] use std::{ - collections::BTreeMap, - error::Error, - sync::{Arc, Mutex, OnceLock}, + sync::{Arc, OnceLock}, time::Duration, }; -use async_executor::{Executor, Task}; +use async_executor::Executor; use async_io::Timer; use futures::executor::block_on; -use tracing::{debug, info, warn, Level}; -use tracing_subscriber::FmtSubscriber; -use twizzler_abi::{ - klog_println, - pager::{ - CompletionToKernel, CompletionToPager, KernelCommand, KernelCompletionData, ObjectRange, - PagerCompletionData, PhysRange, RequestFromKernel, RequestFromPager, - }, +use twizzler_abi::pager::{ + CompletionToKernel, CompletionToPager, PagerCompletionData, PhysRange, RequestFromKernel, + RequestFromPager, }; use twizzler_object::{ObjID, Object, ObjectInitFlags, Protections}; -use crate::{ - data::PagerData, - helpers::{physrange_to_pages, PAGE}, - request_handle::handle_kernel_request, -}; +use crate::{data::PagerData, helpers::physrange_to_pages, request_handle::handle_kernel_request}; mod data; mod helpers; @@ -73,7 +62,7 @@ fn attach_queue( obj_id: ObjID, queue_constructor: impl FnOnce(twizzler_queue::Queue) -> Q, ) -> Result { - tracing::info!("Pager Attaching Queue: {}", obj_id); + tracing::debug!("Pager Attaching Queue: {}", obj_id); let object = Object::init_id( obj_id, @@ -88,10 +77,6 @@ fn attach_queue( Ok(queue_constructor(queue)) } -fn queue_args(i: usize) -> String { - return std::env::args().nth(i).unwrap(); -} - fn queue_init( q1: ObjID, q2: ObjID, @@ -141,13 +126,13 @@ fn health_check( tracing::info!("pager health check start..."); block_on(ex.run(async move { let timeout = Timer::after(timeout_duration); - tracing::info!("submitting request to kernel"); + tracing::debug!("submitting request to kernel"); let res = sq.submit_and_wait(RequestFromPager::new( twizzler_abi::pager::PagerRequest::EchoReq, )); let x = res.await; - tracing::info!(" got {:?} in response", x); + tracing::debug!(" got {:?} in response", x); timeout.await; })); @@ -157,7 +142,7 @@ fn health_check( fn verify_health(health: Result<(), String>) { match health { Ok(()) => tracing::info!("health check successful"), - Err(_) => tracing::info!("gealth check failed"), + Err(_) => tracing::info!("health check failed"), } } @@ -173,7 +158,7 @@ fn pager_init( PagerData, &'static Executor<'static>, ) { - tracing::info!("init start"); + tracing::debug!("init start"); tracing_init(); let data = data_structure_init(); let (rq, sq) = queue_init(q1, q2); @@ -183,7 +168,7 @@ fn pager_init( verify_health(health.clone()); drop(health); - tracing::info!("init complete"); + tracing::debug!("init complete"); return (rq, sq, data, ex); } @@ -192,7 +177,7 @@ fn spawn_queues( data: PagerData, ex: &'static Executor<'static>, ) { - tracing::info!("spawning queues..."); + tracing::debug!("spawning queues..."); ex.spawn(listen_queue(rq, data, handle_kernel_request, ex)) .detach(); } @@ -207,12 +192,12 @@ async fn listen_queue( R: std::fmt::Debug + Copy + Send + Sync + 'static, C: std::fmt::Debug + Copy + Send + Sync + 'static, { - tracing::info!("queue receiving..."); + tracing::debug!("queue receiving..."); let q = Arc::new(q); let data = Arc::new(data); loop { let (id, request) = q.receive().await.unwrap(); - tracing::info!("got request: ({},{:?})", id, request); + tracing::trace!("got request: ({},{:?})", id, request); let qc = Arc::clone(&q); let datac = Arc::clone(&data); @@ -232,7 +217,7 @@ where if let Some(res) = res { q.complete(id, res).await.unwrap(); } - tracing::info!("request {} complete", id); + tracing::trace!("request {} complete", id); } async fn send_request( @@ -243,7 +228,7 @@ where R: std::fmt::Debug + Copy + Send + Sync, C: std::fmt::Debug + Copy + Send + Sync + 'static, { - tracing::info!("submitting request {:?}", request); + tracing::trace!("submitting request {:?}", request); return q .submit_and_wait(request) .await @@ -252,18 +237,18 @@ where async fn report_ready( q: &Arc>, - ex: &'static Executor<'static>, + _ex: &'static Executor<'static>, ) -> Option { - tracing::info!("sending ready signal to kernel"); + tracing::debug!("sending ready signal to kernel"); let request = RequestFromPager::new(twizzler_abi::pager::PagerRequest::Ready); match send_request(q, request).await { Ok(completion) => { - tracing::info!("received completion for ready signal: {:?}", completion); + tracing::debug!("received completion for ready signal: {:?}", completion); return Some(completion.data()); } Err(e) => { - tracing::debug!("error from ready signal {:?}", e); + tracing::warn!("error from ready signal {:?}", e); return None; } } @@ -282,7 +267,7 @@ fn do_pager_start(q1: ObjID, q2: ObjID) { Some(range) // Return the range } _ => { - tracing::debug!("ERROR: no range from ready request"); + tracing::error!("ERROR: no range from ready request"); None } } @@ -296,7 +281,7 @@ fn do_pager_start(q1: ObjID, q2: ObjID) { ); memory_init(data, range); } else { - tracing::info!("cannot complete pager initialization with no physical memory"); + tracing::error!("cannot complete pager initialization with no physical memory"); } tracing::info!("Performing Test..."); @@ -307,26 +292,25 @@ fn do_pager_start(q1: ObjID, q2: ObjID) { }); if let Some(phys_range) = phys_range { - std::thread::sleep(Duration::from_secs(3)); block_on(async move { let mut buf = vec![0u8; 4096]; for (i, b) in (&mut buf).iter_mut().enumerate() { *b = i as u8; } let mut buf2 = vec![0u8; 4096]; - tracing::info!("testing physrw: {:?}", &buf[0..10]); + tracing::debug!("testing physrw: {:?}", &buf[0..10]); assert_ne!(buf, buf2); let start = phys_range.start; let phys = PhysRange { start, end: start + buf.len() as u64, }; - tracing::info!("filling physical pages: {:?} from {:p}", phys, buf.as_ptr()); + tracing::debug!("filling physical pages: {:?} from {:p}", phys, buf.as_ptr()); physrw::fill_physical_pages(&sqc2, buf.as_slice(), phys) .await .unwrap(); - tracing::info!( + tracing::debug!( "reading physical pages: {:?} into {:p}", phys, buf2.as_ptr() diff --git a/src/srv/pager-srv/src/request_handle.rs b/src/srv/pager-srv/src/request_handle.rs index c313423a..a982cc30 100644 --- a/src/srv/pager-srv/src/request_handle.rs +++ b/src/srv/pager-srv/src/request_handle.rs @@ -1,21 +1,18 @@ use std::sync::Arc; use twizzler_abi::pager::{ - CompletionToKernel, CompletionToPager, KernelCommand, KernelCompletionData, ObjectInfo, - ObjectRange, PagerCompletionData, PhysRange, RequestFromKernel, RequestFromPager, + CompletionToKernel, KernelCommand, KernelCompletionData, ObjectInfo, ObjectRange, PhysRange, + RequestFromKernel, }; -use twizzler_object::{ObjID, Object, ObjectInitFlags, Protections}; +use twizzler_object::ObjID; -use crate::{ - data::PagerData, - helpers::{page_to_physrange, physrange_to_pages, PAGE}, -}; +use crate::data::PagerData; fn page_data_req(data: Arc, id: ObjID, range: ObjectRange) -> PhysRange { return data.fill_mem_page(id, range); } -fn object_info_req(data: Arc, id: ObjID) -> ObjectInfo { +fn object_info_req(_data: Arc, id: ObjID) -> ObjectInfo { return ObjectInfo::new(id); } @@ -23,11 +20,11 @@ pub async fn handle_kernel_request( request: RequestFromKernel, data: Arc, ) -> Option { - tracing::info!("handling kernel request {:?}", request); + tracing::debug!("handling kernel request {:?}", request); match request.cmd() { KernelCommand::PageDataReq(obj_id, range) => { - tracing::info!( + tracing::trace!( "handling PageDataReq for ObjID: {:?}, Range: start = {}, end = {}", obj_id, range.start, @@ -39,14 +36,14 @@ pub async fn handle_kernel_request( )) } KernelCommand::ObjectInfoReq(obj_id) => { - tracing::info!("handling ObjectInfo for ObjID: {:?}", obj_id); + tracing::trace!("handling ObjectInfo for ObjID: {:?}", obj_id); let obj_info = object_info_req(data, obj_id); Some(CompletionToKernel::new( KernelCompletionData::ObjectInfoCompletion(obj_info), )) } KernelCommand::EchoReq => { - tracing::info!("handling EchoReq"); + tracing::trace!("handling EchoReq"); Some(CompletionToKernel::new(KernelCompletionData::EchoResp)) } }