Cleanup pass (#253)

* Pass 1.

* Pass 2.

* Pass 3.

* Fix kernel debug parsing.

src/bin/bootstrap/src/main.rs

@@ -132,6 +132,7 @@ extern crate twizzler_minruntime;
 fn main() {
     let subscriber = FmtSubscriber::builder()
         .with_max_level(Level::INFO)
+        .without_time()
         .finish();
 
     tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");

src/bin/devmgr/src/main.rs

@@ -108,10 +108,9 @@ fn start_pcie(seg: Device) {
 
 extern crate twizzler_runtime;
 fn main() {
-    println!("[devmgr] starting device manager {:?}", args());
     logboi::LogHandle::new()
         .unwrap()
-        .log("Hello Logboi, from devmgr!".as_bytes());
+        .log("[devmgr] starting device manager".as_bytes());
     let id = args().into_iter().nth(1).unwrap().parse::<u128>().unwrap();
     let obj = Object::<std::sync::atomic::AtomicU64>::init_id(
         ObjID::new(id),

src/bin/etl_twizzler/src/etl.rs

@@ -2,22 +2,17 @@ use std::{
     fs::File,
     io::{self, BufRead, BufReader, Read, Seek, SeekFrom},
     path::PathBuf,
-    sync::Mutex,
 };
 
-use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 use tar::Header;
 #[cfg(target_os = "twizzler")]
 use twizzler_abi::{
     object::{MAX_SIZE, NULLPAGE_SIZE},
-    syscall::{
-        sys_thread_sync, BackingType, LifetimeType, ObjectCreate, ObjectCreateFlags, ThreadSync,
-        ThreadSyncFlags, ThreadSyncReference, ThreadSyncWake,
-    },
+    syscall::{BackingType, LifetimeType, ObjectCreate, ObjectCreateFlags},
 };
 #[cfg(target_os = "twizzler")]
-use twizzler_object::{ObjID, Object, ObjectInitFlags, Protections};
+use twizzler_object::Protections;
 
 // This type indicates what type of object you want to create, with the name inside
 #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Copy)]
@@ -111,8 +106,8 @@ where
 
 #[cfg(target_os = "twizzler")]
 pub fn form_twizzler_object<R: std::io::Read>(
-    mut stream: R,
-    name: String,
+    stream: R,
+    _name: String,
     offset: u64,
 ) -> std::io::Result<twizzler_object::ObjID> {
     let create = ObjectCreate::new(
@@ -132,7 +127,7 @@ pub fn form_twizzler_object<R: std::io::Read>(
     let slice =
         unsafe { std::slice::from_raw_parts_mut(handle_data_ptr, MAX_SIZE - offset as usize) };
 
-    stream.read(slice);
+    stream.read(slice)?;
 
     Ok(twzid)
 }
@@ -154,7 +149,7 @@ pub fn form_persistent_vector<R: std::io::Read>(
 ) -> std::io::Result<()> {
     let mut writer = File::create(name)?;
     writer.seek(SeekFrom::Start(offset))?;
-    let stream: Vec<String> = BufReader::new(stream)
+    let _stream: Vec<String> = BufReader::new(stream)
         .split(b'\n')
         .filter_map(|result| result.ok())
         .filter_map(|line| String::from_utf8(line).ok())
@@ -198,16 +193,16 @@ where
                     }
                     PackType::TwzObj => {
                         #[cfg(target_os = "twizzler")]
-                        form_twizzler_object(entry, path, bad_idea.offset);
+                        form_twizzler_object(entry, path, bad_idea.offset)?;
                         #[cfg(not(target_os = "twizzler"))]
                         form_fs_file(entry, path, bad_idea.offset)?;
                     }
                     PackType::PVec => {
                         form_persistent_vector(entry, path, bad_idea.offset)?;
                     }
                 }
-            } else if let Err(E) = e {
-                println!("{}", E);
+            } else if let Err(e) = e {
+                println!("{}", e);
             }
         }
 

src/bin/etl_twizzler/src/main.rs

@@ -1,19 +1,6 @@
 use clap::{Parser, Subcommand};
 use etl_twizzler::etl::{Pack, PackType, Unpack};
 
-#[cfg(target_os = "twizzler")]
-use std::sync::atomic::{AtomicU64, Ordering};
-#[cfg(target_os = "twizzler")]
-use twizzler_abi::{
-    object::{MAX_SIZE, NULLPAGE_SIZE},
-    syscall::{
-        sys_thread_sync, BackingType, LifetimeType, ObjectCreate, ObjectCreateFlags, ThreadSync,
-        ThreadSyncFlags, ThreadSyncReference, ThreadSyncWake,
-    },
-};
-#[cfg(target_os = "twizzler")]
-use twizzler_object::{ObjID, Object, ObjectInitFlags, Protections};
-
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 struct Cli {

src/bin/genrandom/src/disk.rs

@@ -1,19 +1,13 @@
 use std::{
-    future, io,
+    io,
     io::{Error, ErrorKind},
-    mem::size_of,
-    sync::{Arc, Mutex, RwLock},
+    sync::Arc,
 };
 
 use layout::{
-    collections::raw::RawBytes,
-    io::{SeekFrom, StdIO},
-    ApplyLayout, Encode, Frame, Read, Seek, SourcedDynamic, Write, IO,
-};
-use lethe_gadget_fat::{
-    filesystem::FileSystem,
-    schema::{self, FATEntry, Superblock},
+    collections::raw::RawBytes, io::SeekFrom, Encode, Read, Seek, SourcedDynamic, Write, IO,
 };
+use lethe_gadget_fat::schema::{self, FATEntry, Superblock};
 use twizzler_async::block_on;
 
 use crate::nvme::{init_nvme, NvmeController};
@@ -66,7 +60,7 @@ pub fn setup(data: &mut Disk) {
 const DISK_SIZE: usize = 0x4_000_000_000 + 0x400;
 const PAGE_SIZE: usize = 4096;
 const SECTOR_SIZE: usize = 512;
-const PAGE_SHIFT: usize = 12;
+const _PAGE_SHIFT: usize = 12;
 const PAGE_MASK: usize = 0xFFF;
 const LBA_COUNT: usize = DISK_SIZE / SECTOR_SIZE;
 
@@ -87,7 +81,7 @@ impl 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]
@@ -102,7 +96,7 @@ impl Read for Disk {
     }
 
     fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
-        self.read(buf);
+        self.read(buf)?;
         Ok(())
     }
 }
@@ -126,25 +120,25 @@ impl 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))?;
                 self.read_exact(&mut write_buffer)?;
-                self.seek(SeekFrom::Start(temp_pos));
+                self.seek(SeekFrom::Start(temp_pos))?;
             }
 
             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;
         }
 
         Ok(bytes_read)
     }
 
     fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
-        self.write(buf);
+        self.write(buf)?;
 
         Ok(())
     }

src/bin/genrandom/src/main.rs

@@ -1,33 +1,20 @@
-#![feature(new_uninit)]
-
 extern crate twizzler_runtime;
 
 use std::{
-    fs::DirBuilder,
-    future,
-    mem::{size_of, zeroed, MaybeUninit},
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc::{self, channel},
-        Arc, Mutex, RwLock,
-    },
+    sync::mpsc::{self},
     thread,
-    time::{Duration, Instant},
+    time::Instant,
 };
 
-use getrandom::{getrandom, getrandom_uninit};
-use layout::{io::SeekFrom, Read, Seek, Write};
-use lethe_gadget_fat::filesystem::FileSystem;
-use twizzler_async::{block_on, Task, Timer};
+use getrandom::getrandom_uninit;
+use layout::{io::SeekFrom, Seek, Write};
 
-use crate::nvme::{init_nvme, NvmeController};
 mod disk;
 mod nvme;
 
 use disk::Disk;
 
 pub fn main() {
-    let id = 20;
     println!("Running genrandom");
 
     let mut d = Disk::new().unwrap();
@@ -43,9 +30,9 @@ pub fn main() {
     // fs.create_object(id, 1500);
     d.seek(SeekFrom::Current(START_OFFSET as i64)).unwrap();
     println!("seeked forward");
-    let mut buf = vec![0u8; BUF_SIZE_USIZE];
+    let _buf = vec![0u8; BUF_SIZE_USIZE];
     let (tx, rx) = mpsc::sync_channel(1);
-    let gen_thread = thread::spawn(move || {
+    let _gen_thread = thread::spawn(move || {
         for i in OFFSET_ITER..ITER_CT {
             let mut buf = Box::new_uninit_slice(BUF_SIZE_USIZE);
             let start = Instant::now();
@@ -61,11 +48,11 @@ pub fn main() {
         }
     });
     let program_start = Instant::now();
-    let write_thread = thread::spawn(move || {
+    let _write_thread = thread::spawn(move || {
         let mut iter_ct = OFFSET_ITER;
         for buf in rx {
             let start = Instant::now();
-            d.write(&buf);
+            d.write(&buf).unwrap();
             let end = Instant::now();
             let curr_dur = end - program_start;
             let iters_passed = iter_ct - OFFSET_ITER + 1;

src/bin/genrandom/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>>>>,
@@ -146,7 +147,7 @@ pub async fn init_controller(ctrl: &mut Arc<NvmeController>) {
 
     let req2 = req.clone();
     let ctrl2 = ctrl.clone();
-    let task = twizzler_async::run(async {
+    let _task = twizzler_async::run(async {
         Task::spawn(async move {
             loop {
                 let _i = int.next().await;
@@ -439,7 +440,7 @@ impl NvmeController {
         ident.dma_region().with(|ident| ident.clone())
     }
 
-    pub async fn flash_len(&self) -> usize {
+    pub async fn _flash_len(&self) -> usize {
         if let Some(sz) = self.capacity.get() {
             *sz
         } else {