Add rust lint CI job. (#9)

Additionally fix the many lint errors that are occurring. (or disable them).

Reviewed-on: #9
Co-authored-by: Drew Galbraith <drew@tiramisu.one>
Co-committed-by: Drew Galbraith <drew@tiramisu.one>

rust/lib/fs/ext2/src/ext2_driver.rs

@@ -94,7 +94,7 @@ impl Ext2Driver {
     /// Updates the cached inode tables to contain the inode table for
     /// a specific group.
     fn populate_inode_table_if_none(&mut self, block_group_num: usize) {
-        if let None = self.inode_table_map[block_group_num] {
+        if self.inode_table_map[block_group_num].is_none() {
             debug!(
                 "Cache MISS on inode table for block_group {}",
                 block_group_num
@@ -148,17 +148,15 @@ impl Ext2Driver {
         let dbl_indr_block_mem =
             MemoryRegion::from_cap(self.reader.read(block_num, 1).unwrap()).unwrap();
 
-        let dbl_indr_blocks: &[u32] = dbl_indr_block_mem.slice();
+        let dbl_indr_blocks: &[u32] = &dbl_indr_block_mem.slice()[0..num_dbl_indr];
 
         let mut blocks_to_read = Vec::new();
 
-        for i in 0..num_dbl_indr {
+        for (i, dbl_indr_block) in dbl_indr_blocks.iter().enumerate() {
             let num_blocks_in_single = min(num_blocks - (256 * i), 256);
             blocks_to_read.append(
-                &mut self.get_blocks_from_single_indirect(
-                    dbl_indr_blocks[i] as u64,
-                    num_blocks_in_single,
-                ),
+                &mut self
+                    .get_blocks_from_single_indirect(*dbl_indr_block as u64, num_blocks_in_single),
             );
         }
 
@@ -176,7 +174,7 @@ impl Ext2Driver {
 
         let mut blocks = Vec::new();
 
-        while let Some(block) = iter.next() {
+        for block in iter {
             if block as u64 == (curr_block.lba + curr_block.size) {
                 curr_block.size += 1;
             } else {

rust/lib/fs/ext2/src/types.rs

@@ -111,7 +111,9 @@ pub struct Inode {
 
 const _: () = assert!(size_of::<Inode>() == 128);
 
+#[allow(dead_code)]
 pub const EXT2_FT_FILE: u8 = 0x1;
+#[allow(dead_code)]
 pub const EXT2_FT_DIR: u8 = 0x2;
 
 #[repr(C, packed)]

rust/lib/mammoth/src/cap_syscall.rs

@@ -2,7 +2,6 @@ use core::ffi::c_void;
 
 use crate::zion::{self, z_cap_t, ZError};
 
-#[must_use]
 fn syscall<T>(id: u64, req: &T) -> Result<(), ZError> {
     unsafe {
         let resp = zion::SysCall1(id, req as *const T as *const c_void);

rust/lib/mammoth/src/elf.rs

@@ -1,5 +1,4 @@
 use crate::cap::Capability;
-use crate::debug;
 use crate::init;
 use crate::syscall;
 use crate::zion::ZError;
@@ -237,7 +236,7 @@ fn load_program_segment(
             let page_offset = prog_header.vaddr & 0xFFF;
             let mem_size = page_offset + prog_header.mem_size;
 
-            let mem_object = crate::mem::MemoryRegion::new(mem_size)?;
+            let mut mem_object = crate::mem::MemoryRegion::new(mem_size)?;
 
             for i in mem_object.mut_slice() {
                 *i = 0;

rust/lib/mammoth/src/init.rs

@@ -28,7 +28,7 @@ pub fn parse_init_port(port_cap: z_cap_t) {
         let mut caps: [u64; 1] = [0];
 
         let resp = syscall::port_poll(&init_port, &mut bytes, &mut caps);
-        if let Err(_) = resp {
+        if resp.is_err() {
             break;
         }
 

rust/lib/mammoth/src/macros.rs

@@ -2,21 +2,20 @@ use alloc::string::String;
 use alloc::vec::Vec;
 use core::fmt;
 
+#[derive(Default)]
 pub struct Writer {
     int_vec: Vec<u8>,
 }
 
 impl Writer {
     pub fn new() -> Self {
-        Self {
-            int_vec: Vec::new(),
-        }
+        Writer::default()
     }
 }
 
-impl Into<String> for Writer {
-    fn into(self) -> String {
-        String::from_utf8(self.int_vec).expect("Failed to convert")
+impl From<Writer> for String {
+    fn from(value: Writer) -> Self {
+        String::from_utf8(value.int_vec).expect("Failed to convert")
     }
 }
 

rust/lib/mammoth/src/mem.rs

@@ -85,7 +85,7 @@ impl MemoryRegion {
         }
     }
 
-    pub fn mut_slice<T>(&self) -> &mut [T] {
+    pub fn mut_slice<T>(&mut self) -> &mut [T] {
         unsafe {
             slice::from_raw_parts_mut(
                 self.virt_addr as *mut T,

rust/lib/mammoth/src/sync.rs

@@ -50,7 +50,7 @@ impl<T> DerefMut for MutexGuard<'_, T> {
     }
 }
 
-impl<T> Mutex<T> {
+impl<'a, T> Mutex<T> {
     pub fn new(data: T) -> Mutex<T> {
         Mutex {
             cap: syscall::mutex_create().unwrap(),
@@ -58,7 +58,7 @@ impl<T> Mutex<T> {
         }
     }
 
-    pub fn lock(&self) -> MutexGuard<T> {
+    pub fn lock(&'a self) -> MutexGuard<'a, T> {
         syscall::mutex_lock(&self.cap).unwrap();
 
         MutexGuard { mutex: self }
@@ -70,3 +70,12 @@ impl<T> Drop for MutexGuard<'_, T> {
         syscall::mutex_release(&self.mutex.cap).unwrap();
     }
 }
+
+impl<T> Default for Mutex<T>
+where
+    T: Default,
+{
+    fn default() -> Self {
+        Self::new(T::default())
+    }
+}

rust/lib/mammoth/src/syscall.rs

@@ -9,7 +9,6 @@ use core::ffi::c_void;
 #[cfg(feature = "hosted")]
 use core::panic::PanicInfo;
 
-#[must_use]
 fn syscall<T>(id: u64, req: &T) -> Result<(), ZError> {
     unsafe {
         let resp = zion::SysCall1(id, req as *const T as *const c_void);

rust/lib/mammoth/src/task/mod.rs

@@ -48,7 +48,7 @@ struct TaskWaker {
 }
 
 impl TaskWaker {
-    fn new(task_id: TaskId, task_queue: Arc<Mutex<VecDeque<TaskId>>>) -> Waker {
+    fn create_waker(task_id: TaskId, task_queue: Arc<Mutex<VecDeque<TaskId>>>) -> Waker {
         Waker::from(Arc::new(TaskWaker {
             task_id,
             task_queue,
@@ -69,6 +69,7 @@ impl Wake for TaskWaker {
     }
 }
 
+#[derive(Default)]
 pub struct Executor {
     tasks: Arc<Mutex<BTreeMap<TaskId, Task>>>,
     // TODO: Consider a better datastructure for this.
@@ -78,11 +79,7 @@ pub struct Executor {
 
 impl Executor {
     pub fn new() -> Executor {
-        Executor {
-            tasks: Arc::new(Mutex::new(BTreeMap::new())),
-            task_queue: Arc::new(Mutex::new(VecDeque::new())),
-            waker_cache: BTreeMap::new(),
-        }
+        Executor::default()
     }
 
     pub fn spawn(&mut self, task: Task) {
@@ -100,7 +97,7 @@ impl Executor {
             let waker = self
                 .waker_cache
                 .entry(task_id)
-                .or_insert_with(|| TaskWaker::new(task_id, self.task_queue.clone()));
+                .or_insert_with(|| TaskWaker::create_waker(task_id, self.task_queue.clone()));
             let mut ctx = Context::from_waker(waker);
             match task.poll(&mut ctx) {
                 Poll::Ready(()) => {

rust/lib/mammoth/src/thread.rs

@@ -40,7 +40,7 @@ where
     let raw_main = Box::into_raw(Box::new(main));
     let proc_cap = Capability::take_copy(unsafe { crate::init::SELF_PROC_CAP }).unwrap();
     let cap = syscall::thread_create(&proc_cap).unwrap();
-    syscall::thread_start(&cap, entry_point as u64, raw_main as u64, 0).unwrap();
+    syscall::thread_start(&cap, entry_point as usize as u64, raw_main as u64, 0).unwrap();
 
     JoinHandle { cap }
 }

rust/lib/pci/src/device.rs

@@ -2,8 +2,7 @@ use alloc::vec::Vec;
 use mammoth::{cap::Capability, mem::MemoryRegion, syscall, zion::ZError};
 
 use crate::header::{
-    PciCapabilityPointer, PciDeviceHeader, PciHeaderType, PciMsiCapability, PciMsiControl,
-    get_header_type,
+    PciCapabilityPointer, PciDeviceHeader, PciHeaderType, PciMsiCapability, get_header_type,
 };
 
 pub struct PciDevice {
@@ -11,7 +10,7 @@ pub struct PciDevice {
 }
 
 impl PciDevice {
-    pub fn from(mut memory_region: MemoryRegion) -> Result<Self, ZError> {
+    pub fn from(memory_region: MemoryRegion) -> Result<Self, ZError> {
         match get_header_type(&memory_region)? {
             PciHeaderType::Device => {}
             t => {

rust/lib/voyageurs/src/listener.rs

@@ -7,7 +7,7 @@ use mammoth::thread;
 #[allow(dead_code)]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
 enum Keycode {
-    UnknownKeycode = 0x0,
+    Unknown = 0x0,
 
     A = 0x1,
     B = 0x2,
@@ -135,7 +135,7 @@ impl Keycode {
             0x37 => Keycode::Period,
             0x38 => Keycode::FSlash,
             0x39 => Keycode::Esc,
-            _ => Keycode::UnknownKeycode,
+            _ => Keycode::Unknown,
         }
     }
 }

rust/lib/yellowstone/src/lib.rs

@@ -10,10 +10,12 @@ static mut YELLOWSTONE_INIT: Option<YellowstoneClient> = None;
 
 pub fn from_init_endpoint() -> &'static mut YellowstoneClient {
     unsafe {
-        if let None = YELLOWSTONE_INIT {
+        #[allow(static_mut_refs)]
+        if YELLOWSTONE_INIT.is_none() {
             YELLOWSTONE_INIT = Some(YellowstoneClient::new(Capability::take(INIT_ENDPOINT)));
         }
 
+        #[allow(static_mut_refs)]
         YELLOWSTONE_INIT.as_mut().unwrap()
     }
 }

rust/lib/yunq-test/src/lib.rs

@@ -12,7 +12,11 @@ mod tests {
 
     #[test]
     fn basic_serialization() -> Result<(), ZError> {
-        let basic = Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string() };
+        let basic = Basic {
+            unsigned_int: 82,
+            signed_int: -1234,
+            strn: "abc".to_string(),
+        };
 
         let mut buf = ByteBuffer::<1024>::new();
         let mut caps = Vec::new();
@@ -27,13 +31,17 @@ mod tests {
 
     #[test]
     fn basic_serialization_as_request() -> Result<(), ZError> {
-        let basic = Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string() };
+        let basic = Basic {
+            unsigned_int: 82,
+            signed_int: -1234,
+            strn: "abc".to_string(),
+        };
 
         let mut buf = ByteBuffer::<1024>::new();
         let mut caps = Vec::new();
         let req_id = 12;
         basic.serialize_as_request(req_id, &mut buf, &mut caps)?;
-        
+
         assert!(buf.at::<u64>(8)? == req_id);
 
         let parsed = Basic::parse_from_request(&buf, &caps)?;
@@ -50,7 +58,7 @@ mod tests {
         let mut buf = ByteBuffer::<1024>::new();
         let mut caps = Vec::new();
         cap.serialize(&mut buf, 0, &mut caps)?;
-        
+
         assert!(caps.len() == 1);
         assert!(caps[0] == cap_id);
 
@@ -63,12 +71,14 @@ mod tests {
 
     #[test]
     fn repeated_serialization() -> Result<(), ZError> {
-        let rep = Repeated { unsigned_ints: vec![0, 1, 3],};
+        let rep = Repeated {
+            unsigned_ints: vec![0, 1, 3],
+        };
 
         let mut buf = ByteBuffer::<1024>::new();
         let mut caps = Vec::new();
         rep.serialize(&mut buf, 0, &mut caps)?;
-        
+
         let parsed = Repeated::parse(&buf, 0, &caps)?;
 
         assert!(parsed == rep);
@@ -79,17 +89,20 @@ mod tests {
     #[test]
     fn nested_serialization() -> Result<(), ZError> {
         let nested = Nested {
-            basic:  Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string() },
-            cap1: Cap { cap: 37},
-            cap2: Cap { cap: 39},
+            basic: Basic {
+                unsigned_int: 82,
+                signed_int: -1234,
+                strn: "abc".to_string(),
+            },
+            cap1: Cap { cap: 37 },
+            cap2: Cap { cap: 39 },
         };
 
         let mut buf = ByteBuffer::<1024>::new();
         let mut caps = Vec::new();
         nested.serialize(&mut buf, 0, &mut caps)?;
-        
-        let parsed = Nested::parse(&buf, 0, &caps)?;
 
+        let parsed = Nested::parse(&buf, 0, &caps)?;
 
         assert!(parsed == nested);
 
@@ -99,23 +112,29 @@ mod tests {
     #[test]
     fn repeated_nested_serialization() -> Result<(), ZError> {
         let nested = RepeatedNested {
-            basics:  vec![Basic { unsigned_int: 82, signed_int: -1234, strn: "abc".to_string(),},
-            Basic { unsigned_int: 21, signed_int: -8, strn: "def".to_string(), },],
-            caps: vec![Cap{ cap: 123}, Cap {cap: 12343}],
+            basics: vec![
+                Basic {
+                    unsigned_int: 82,
+                    signed_int: -1234,
+                    strn: "abc".to_string(),
+                },
+                Basic {
+                    unsigned_int: 21,
+                    signed_int: -8,
+                    strn: "def".to_string(),
+                },
+            ],
+            caps: vec![Cap { cap: 123 }, Cap { cap: 12343 }],
         };
 
         let mut buf = ByteBuffer::<1024>::new();
         let mut caps = Vec::new();
         nested.serialize(&mut buf, 0, &mut caps)?;
-        
-        let parsed = RepeatedNested::parse(&buf, 0, &caps)?;
 
+        let parsed = RepeatedNested::parse(&buf, 0, &caps)?;
 
         assert!(parsed == nested);
 
-
         Ok(())
     }
-
-
 }

rust/lib/yunq/src/buffer.rs

@@ -5,12 +5,19 @@ pub struct ByteBuffer<const N: usize> {
     buffer: Box<[u8; N]>,
 }
 
-impl<const N: usize> ByteBuffer<N> {
-    pub fn new() -> Self {
+impl<const N: usize> Default for ByteBuffer<N> {
+    fn default() -> Self {
         Self {
             buffer: Box::new([0; N]),
         }
     }
+}
+
+impl<const N: usize> ByteBuffer<N> {
+    pub fn new() -> Self {
+        ByteBuffer::default()
+    }
+
     pub fn size(&self) -> u64 {
         N as u64
     }
@@ -54,7 +61,7 @@ impl<const N: usize> ByteBuffer<N> {
         if (len + offset) > N {
             return Err(ZError::BUFFER_SIZE);
         }
-        Ok(alloc::str::from_utf8(&self.buffer[offset..offset + len])
-            .map_err(|_| ZError::INVALID_ARGUMENT)?)
+        alloc::str::from_utf8(&self.buffer[offset..offset + len])
+            .map_err(|_| ZError::INVALID_ARGUMENT)
     }
 }

rust/lib/yunq/src/client.rs

@@ -34,5 +34,5 @@ pub fn call_endpoint<Req: YunqMessage, Resp: YunqMessage, const N: usize>(
         return Err(ZError::from(resp_code));
     }
 
-    Ok(Resp::parse_from_request(&byte_buffer, &cap_buffer)?)
+    Resp::parse_from_request(byte_buffer, &cap_buffer)
 }

rust/lib/yunq/src/message.rs

@@ -28,7 +28,7 @@ pub fn parse_repeated_message<T: YunqMessage, const N: usize>(
     buf: &ByteBuffer<N>,
     mut offset: usize,
     len: usize,
-    caps: &Vec<z_cap_t>,
+    caps: &[z_cap_t],
 ) -> Result<Vec<T>, ZError> {
     let mut repeated = Vec::new();
     for _ in 0..len {
@@ -43,18 +43,18 @@ pub fn parse_repeated_message<T: YunqMessage, const N: usize>(
 pub fn serialize_repeated<T: Copy, const N: usize>(
     buf: &mut ByteBuffer<N>,
     offset: usize,
-    data: &Vec<T>,
+    data: &[T],
 ) -> Result<usize, ZError> {
-    for i in 0..data.len() {
-        buf.write_at(offset + (i * size_of::<T>()), data[i])?;
+    for (i, val) in data.iter().enumerate() {
+        buf.write_at(offset + (i * size_of::<T>()), val)?;
     }
-    Ok(offset + (data.len() * size_of::<T>()))
+    Ok(offset + size_of_val(data))
 }
 
 pub fn serialize_repeated_message<T: YunqMessage, const N: usize>(
     buf: &mut ByteBuffer<N>,
     mut offset: usize,
-    data: &Vec<T>,
+    data: &[T],
     caps: &mut Vec<z_cap_t>,
 ) -> Result<usize, ZError> {
     for item in data {
@@ -76,14 +76,14 @@ pub trait YunqMessage {
     fn parse<const N: usize>(
         buf: &ByteBuffer<N>,
         offset: usize,
-        caps: &Vec<z_cap_t>,
+        caps: &[z_cap_t],
     ) -> Result<Self, ZError>
     where
         Self: Sized;
 
     fn parse_from_request<const N: usize>(
         buf: &ByteBuffer<N>,
-        caps: &Vec<z_cap_t>,
+        caps: &[z_cap_t],
     ) -> Result<Self, ZError>
     where
         Self: Sized,
@@ -92,7 +92,7 @@ pub trait YunqMessage {
             return Err(ZError::INVALID_RESPONSE);
         }
 
-        Ok(Self::parse(&buf, 16, &caps)?)
+        Self::parse(buf, 16, caps)
     }
 
     fn serialize<const N: usize>(
@@ -109,7 +109,7 @@ pub trait YunqMessage {
         caps: &mut Vec<z_cap_t>,
     ) -> Result<usize, ZError> {
         buf.write_at(0, SENTINEL)?;
-        buf.write_at(8, request_id as u64)?;
+        buf.write_at(8, request_id)?;
 
         let length = self.serialize(buf, 16, caps)?;
 
@@ -125,7 +125,7 @@ impl YunqMessage for Empty {
     fn parse<const N: usize>(
         _buf: &ByteBuffer<N>,
         _offset: usize,
-        _caps: &Vec<z_cap_t>,
+        _caps: &[z_cap_t],
     ) -> Result<Self, ZError>
     where
         Self: Sized,

rust/lib/yunq/src/server.rs

@@ -37,7 +37,7 @@ pub trait YunqServer {
                 .expect("Failed to reply"),
                 Err(err) => {
                     crate::message::serialize_error(&mut byte_buffer, err);
-                    syscall::reply_port_send(reply_port_cap, &byte_buffer.slice(0x10), &[])
+                    syscall::reply_port_send(reply_port_cap, byte_buffer.slice(0x10), &[])
                         .expect("Failed to reply w/ error")
                 }
             }
@@ -84,11 +84,11 @@ where
                 .at::<u64>(8)
                 .expect("Failed to access request length.");
             let self_clone = self.clone();
-            spawner.spawn(Task::new((async move || {
+            spawner.spawn(Task::new(async move {
                 self_clone
                     .handle_request_and_response(method, byte_buffer, cap_buffer, reply_port_cap)
-                    .await;
-            })()));
+                    .await
+            }));
         }
     }
 
@@ -113,12 +113,10 @@ where
                 .expect("Failed to reply"),
                 Err(err) => {
                     crate::message::serialize_error(&mut byte_buffer, err);
-                    syscall::reply_port_send(reply_port_cap, &byte_buffer.slice(0x10), &[])
+                    syscall::reply_port_send(reply_port_cap, byte_buffer.slice(0x10), &[])
                         .expect("Failed to reply w/ error")
                 }
             }
-
-            ()
         }
     }