Adjust tracing levels.

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));

src/kernel/src/queue.rs

@@ -154,7 +154,6 @@ impl<S: Copy, C: Copy> QueueObject<S, C> {
     }
 
     pub fn complete(&self, item: C, info: u32) {
-        logln!("kernel: completing!! {}", info);
         self.completions.send(item, info)
     }
 

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<Disk> = OnceLock::new();
 pub static FS: LazyLock<Mutex<FileSystem<Disk>>> = 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,17 +107,18 @@ 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]);
             bytes_read += right - left;
 
             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;

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<Vec<Requester<NvmeRequester>>>,
     admin_requester: RwLock<Option<Arc<Requester<NvmeRequester>>>>,
@@ -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

src/srv/pager-srv/object-store/src/object_store.rs

@@ -39,7 +39,7 @@ pub fn create_object(obj_id: u128) -> Result<bool, Error> {
         Ok(_) => Ok(false),
         Err(e) => match e {
             fatfs::Error::NotFound => {
-                subdir.create_file(&b64);
+                subdir.create_file(&b64).unwrap();
                 Ok(true)
             }
             _ => Err(e.into()),

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,26 +42,26 @@ 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<usize> {
-        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
         }
     }
 
     /// 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,24 +72,24 @@ 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")
     }
 
     /// 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,30 +141,30 @@ 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
             }
         }
     }
 
     /// 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,15 +173,15 @@ 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())),
         }
     }
 
     /// 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;
     }
 }

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;