misc(kernel): cleanup

Andy-Python-Programmer · Andy-Python-Programmer · commit 0476db68a991 · 2024-04-03T18:50:27.000+11:00
Signed-off-by: Anhad Singh &lt;andypythonappdeveloper@gmail.com&gt;
diff --git a/src/aero_kernel/src/arch/x86_64/apic.rs b/src/aero_kernel/src/arch/x86_64/apic.rs
@@ -29,7 +29,6 @@ use crate::utils::sync::{Mutex, MutexGuard};
 use super::{io, time};
 
 use crate::acpi::madt;
-use crate::PHYSICAL_MEMORY_OFFSET;
 
 const APIC_SPURIOUS_VECTOR: u32 = 0xFF;
 
diff --git a/src/aero_kernel/src/drivers/block/nvme/mod.rs b/src/aero_kernel/src/drivers/block/nvme/mod.rs
@@ -21,7 +21,7 @@ mod queue;
 use core::mem::MaybeUninit;
 
 use command::*;
-use queue::*;
+use queue::QueuePair;
 
 use alloc::sync::Arc;
 use alloc::vec::Vec;
@@ -281,8 +281,8 @@ impl<'a> Controller<'a> {
         let bar0 = header.get_bar(0).ok_or(Error::UnknownBar)?;
 
         // All NVMe registers are accessible via BAR0.
-        let (registers_addr, bar_size) = match bar0 {
-            Bar::Memory64 { address, size, .. } => (PhysAddr::new(address), size),
+        let registers_addr = match bar0 {
+            Bar::Memory64 { address, .. } => PhysAddr::new(address),
             _ => return Err(Error::UnknownBar),
         };
 
@@ -538,7 +538,7 @@ impl PciDeviceHandle for Handler<'static> {
 
         for device_name in devices {
             let device = BlockDevice::new(device_name, controller.clone());
-            install_block_device(device).expect("nvme: failed to install the block device")
+            install_block_device(device).expect("nvme: failed to install the block device");
         }
 
         self.controllers.lock().push(controller);
@@ -551,7 +551,7 @@ fn irq_handler(_stack: &mut InterruptStack) {
 
 fn nvme_init() {
     // Register the NVMe device handler.
-    register_device_driver(Handler::new())
+    register_device_driver(Handler::new());
 }
 
 crate::module_init!(nvme_init, ModuleType::Block);
diff --git a/src/aero_kernel/src/drivers/pci.rs b/src/aero_kernel/src/drivers/pci.rs
@@ -679,7 +679,9 @@ impl PciHeader {
 
         // bit 0:true  - the BAR is in memory
         // bit 0:false - the BAR is in I/O
-        if !bar.get_bit(0) {
+        if bar.get_bit(0) {
+            Some(Bar::IO(bar.get_bits(2..32)))
+        } else {
             let prefetchable = bar.get_bit(3);
             let address = bar.get_bits(4..32) << 4;
 
@@ -727,8 +729,6 @@ impl PciHeader {
 
                 _ => None,
             }
-        } else {
-            Some(Bar::IO(bar.get_bits(2..32)))
         }
     }
 
diff --git a/src/aero_kernel/src/drivers/pty.rs b/src/aero_kernel/src/drivers/pty.rs
@@ -26,7 +26,7 @@ use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 use spin::{Once, RwLock};
 
-use uapi::pty::*;
+use uapi::pty::TIOCGPTN;
 
 use crate::arch::user_copy::UserRef;
 use crate::fs::cache::*;
@@ -107,8 +107,6 @@ struct Master {
 
 impl Master {
     pub fn new() -> Self {
-        use aero_syscall::*;
-
         Self {
             id: PTY_ID.fetch_add(1, Ordering::SeqCst),
             wq: WaitQueue::new(),
@@ -191,8 +189,8 @@ impl TerminalDevice for Slave {
     }
 
     fn detach(&self, task: Arc<Task>) {
-        use aero_syscall::signal::*;
-        use aero_syscall::*;
+        use aero_syscall::signal::SIGINT;
+        use aero_syscall::VINTR;
 
         if !self.master.discipline.termios.lock().is_cooked() {
             return;
diff --git a/src/aero_kernel/src/drivers/uart_16550.rs b/src/aero_kernel/src/drivers/uart_16550.rs
@@ -47,7 +47,7 @@ bitflags::bitflags! {
 pub struct SerialPort(u16);
 
 impl SerialPort {
-    #[inline(always)]
+    #[inline]
     pub const fn new(port: u16) -> Self {
         Self(port)
     }
@@ -90,7 +90,7 @@ impl SerialPort {
 
     fn wait_for_line_status(&self, line_status: LineStatus) {
         while !self.line_status().contains(line_status) {
-            core::hint::spin_loop()
+            core::hint::spin_loop();
         }
     }
 
diff --git a/src/aero_kernel/src/fs/block/gpt.rs b/src/aero_kernel/src/fs/block/gpt.rs
@@ -23,7 +23,7 @@ use core::mem::MaybeUninit;
 use alloc::boxed::Box;
 use alloc::sync::Arc;
 
-const GPT_TABLE_SIGNATURE: u64 = 0x5452415020494645;
+const GPT_TABLE_SIGNATURE: u64 = 0x5452_4150_2049_4645;
 
 #[repr(C)]
 pub struct GptTableHeader {
diff --git a/src/aero_kernel/src/fs/inode.rs b/src/aero_kernel/src/fs/inode.rs
@@ -286,7 +286,7 @@ pub trait INodeInterface: Send + Sync {
 }
 
 /// Structure representing the crucial, characteristics of an inode. The metadata
-/// of an inode can be retrieved by invoking the [INodeInterface::metadata] function.
+/// of an inode can be retrieved by invoking the [`INodeInterface::metadata`] function.
 #[derive(Debug, Copy, Clone)]
 pub struct Metadata {
     pub id: usize,
@@ -345,7 +345,7 @@ pub enum FileContents {
     /// and is backed by a static byte buffer
     StaticContent(&'static [u8]),
 
-    /// If the file type of the inode is [FileType::Device], in that case this variant
+    /// If the file type of the inode is [`FileType::Device`], in that case this variant
     /// is used.
     Device(Arc<DevINode>),
 
diff --git a/src/aero_kernel/src/fs/path.rs b/src/aero_kernel/src/fs/path.rs
@@ -138,7 +138,7 @@ impl PathBuf {
             self.as_mut_vec().truncate(0);
         }
 
-        let need_sep = self.0.chars().last().map(|c| c != '/').unwrap_or(false);
+        let need_sep = self.0.chars().last().is_some_and(|c| c != '/');
 
         // TODO: verbatim pahts need . and .. removed
 
diff --git a/src/aero_kernel/src/mem/mod.rs b/src/aero_kernel/src/mem/mod.rs
@@ -23,9 +23,7 @@ mod vmalloc;
 
 use ::alloc::boxed::Box;
 
-use crate::mem::paging::*;
-
-use self::paging::{active_level_4_table, FRAME_ALLOCATOR};
+use paging::*;
 
 /// Structure representing a *virtual* address space. The address space
 /// contains a reference of the page table allocated for this address space.
diff --git a/src/aero_kernel/src/mem/paging/addr.rs b/src/aero_kernel/src/mem/paging/addr.rs
@@ -97,19 +97,19 @@ impl VirtAddr {
     /// Converts the address to a raw pointer.
     #[cfg(target_pointer_width = "64")]
     #[inline]
-    pub fn as_ptr<T>(self) -> *const T {
+    pub const fn as_ptr<T>(self) -> *const T {
         self.as_u64() as *const T
     }
 
     /// Converts the address to a mutable raw pointer.
     #[cfg(target_pointer_width = "64")]
     #[inline]
-    pub fn as_mut_ptr<T>(self) -> *mut T {
-        self.as_ptr::<T>() as *mut T
+    pub const fn as_mut_ptr<T>(self) -> *mut T {
+        self.as_ptr::<T>().cast_mut()
     }
 
     #[inline]
-    pub fn is_zero(self) -> bool {
+    pub const fn is_zero(self) -> bool {
         self.0 == 0
     }
 
@@ -360,12 +360,6 @@ impl Step for VirtAddr {
     }
 }
 
-/// A passed `u64` was not a valid physical address.
-///
-/// This means that bits 52 to 64 were not all null.
-#[derive(Debug)]
-pub struct PhysAddrNotValid(u64);
-
 impl PhysAddr {
     /// Creates a new physical address.
     ///
@@ -570,7 +564,7 @@ pub fn align_down(addr: u64, align: u64) -> u64 {
 /// Panics if the alignment is not a power of two. Without the `const_fn`
 /// feature, the panic message will be "index out of bounds".
 #[inline]
-pub fn align_up(addr: u64, align: u64) -> u64 {
+pub const fn align_up(addr: u64, align: u64) -> u64 {
     let align_mask = align - 1;
 
     if addr & align_mask == 0 {
@@ -581,7 +575,7 @@ pub fn align_up(addr: u64, align: u64) -> u64 {
 }
 
 #[inline]
-pub fn is_aligned(addr: u64, align: u64) -> bool {
+pub const fn is_aligned(addr: u64, align: u64) -> bool {
     align_up(addr, align) == addr
 }
 
diff --git a/src/aero_kernel/src/mem/paging/frame.rs b/src/aero_kernel/src/mem/paging/frame.rs
@@ -418,9 +418,9 @@ impl GlobalFrameAllocator {
 
             if mask & address.as_u64() != 0 {
                 continue;
-            } else {
-                return order;
             }
+
+            return order;
         }
 
         0
diff --git a/src/aero_kernel/src/mem/paging/page_table.rs b/src/aero_kernel/src/mem/paging/page_table.rs
@@ -49,7 +49,7 @@ impl PageTableEntry {
     // page table entry counter.
     const COUNTER_MASK: u64 = 0x7ff0_0000_0000_0000;
     const COUNTER_SHIFT: u64 = 52;
-    const FLAGS_MASK: u64 = 0x80000000000001ff;
+    const FLAGS_MASK: u64 = 0x8000_0000_0000_01ff;
 
     /// Creates an unused page table entry.
     pub const fn new() -> Self {
diff --git a/src/aero_kernel/src/modules.rs b/src/aero_kernel/src/modules.rs
@@ -33,7 +33,7 @@ use core::mem::size_of;
 
 use crate::{drivers, extern_sym, fs};
 
-/// Inner helper function to make sure the function provided to the [module_init] macro
+/// Inner helper function to make sure the function provided to the [`module_init`] macro
 /// has a valid function signature. This function returns the passed module init function as
 /// a const void pointer.
 
diff --git a/src/aero_kernel/src/net/arp.rs b/src/aero_kernel/src/net/arp.rs
@@ -76,9 +76,7 @@ impl Cache {
     }
 
     fn request(&mut self, ip: Ipv4Addr, packet: RawPacket) {
-        if ip == Ipv4Addr::LOOPBACK {
-            panic!()
-        }
+        assert!(ip != Ipv4Addr::LOOPBACK);
 
         if self.0.get_mut(&ip).is_some() {
             todo!()
diff --git a/src/aero_kernel/src/net/loopback.rs b/src/aero_kernel/src/net/loopback.rs
@@ -49,12 +49,12 @@ impl NetworkDriver for Loopback {
 }
 
 lazy_static::lazy_static! {
-    pub static ref LOOPBACK: Arc<NetworkDevice> = (|| {
+    pub static ref LOOPBACK: Arc<NetworkDevice> = {
         let device = Arc::new(NetworkDevice::new(Arc::new(Loopback)));
 
         device.set_ip(Ipv4Addr::LOOPBACK);
         device.set_subnet_mask(Ipv4Addr::new(255, 0, 0, 0));
 
         device
-    })();
+    };
 }
diff --git a/src/aero_kernel/src/net/mod.rs b/src/aero_kernel/src/net/mod.rs
@@ -67,7 +67,6 @@ impl NetworkDevice {
             // What should the default be? Also this should really be handled inside dhcpd.
             default_gateway: Ipv4Addr::new(10, 0, 2, 2),
             subnet_mask: Ipv4Addr::new(255, 255, 255, 0),
-            ..Default::default()
         };
 
         Self {
diff --git a/src/aero_kernel/src/socket/netlink.rs b/src/aero_kernel/src/socket/netlink.rs
@@ -33,7 +33,6 @@ use alloc::vec::Vec;
 use crabnet::network::Ipv4Addr;
 
 use crate::fs;
-use crate::fs::cache::DirCacheImpl;
 use crate::fs::inode::{FileType, INodeInterface, Metadata, PollFlags, PollTable};
 use crate::utils::sync::{Mutex, WaitQueue};
 
@@ -61,7 +60,7 @@ impl NetlinkBuilder {
         Self { buffer: Vec::new() }
     }
 
-    fn header(&mut self, header: netlink::nlmsghdr) {
+    fn header(&mut self, header: &netlink::nlmsghdr) {
         self.buffer.extend_from_slice(unsafe {
             core::slice::from_raw_parts(
                 &header as *const _ as *const u8,
@@ -72,7 +71,7 @@ impl NetlinkBuilder {
         self.buffer_align();
     }
 
-    fn message(&mut self, message: netlink::rtmsg) {
+    fn message(&mut self, message: &netlink::rtmsg) {
         self.buffer.extend_from_slice(unsafe {
             core::slice::from_raw_parts(
                 &message as *const _ as *const u8,
@@ -154,15 +153,15 @@ impl NetLinkSocket {
     fn send_route_packet(&self, header: &netlink::nlmsghdr) {
         let mut builder = NetlinkBuilder::new();
 
-        builder.header(netlink::nlmsghdr {
+        builder.header(&netlink::nlmsghdr {
             nlmsg_type: MessageType::RtmNewRoute,
             nlmsg_flags: MessageFlags::MULTI,
             nlmsg_seq: header.nlmsg_seq,
             nlmsg_pid: 0,
             nlmsg_len: 0,
         });
 
-        builder.message(netlink::rtmsg {
+        builder.message(&netlink::rtmsg {
             rtm_family: AF_INET as u8,
             rtm_dst_len: 0, // FIXME
             rtm_src_len: 0,
@@ -259,13 +258,11 @@ impl INodeInterface for NetLinkSocket {
 
                 bytes_copied += copy;
                 iovecs.remove(index);
+            } else if flags.contains(socket::MessageFlags::TRUNC) && bytes_copied == 0 {
+                message_hdr.flags = socket::MessageFlags::TRUNC.bits() as i32;
+                return Ok(data.len());
             } else {
-                if flags.contains(socket::MessageFlags::TRUNC) && bytes_copied == 0 {
-                    message_hdr.flags = socket::MessageFlags::TRUNC.bits() as i32;
-                    return Ok(data.len());
-                } else {
-                    unimplemented!()
-                }
+                unimplemented!()
             }
         }
 
diff --git a/src/aero_kernel/src/socket/tcp.rs b/src/aero_kernel/src/socket/tcp.rs
@@ -78,10 +78,7 @@ impl TcpSocket {
     pub fn on_packet(&self, tcp: &Tcp, options: TcpOptions, payload: &[u8]) {
         if let Some(socket) = self.tcp.lock_irq().as_mut() {
             // Ignore any invalid TCP options.
-            let options = options
-                .iter()
-                .filter_map(|option| option.ok())
-                .collect::<Vec<_>>();
+            let options = options.iter().filter_map(Result::ok).collect::<Vec<_>>();
 
             socket.on_packet(tcp, &options, payload);
             self.wq.notify_all();
@@ -96,8 +93,7 @@ impl TcpSocket {
     pub fn non_blocking(&self) -> bool {
         self.handle
             .get()
-            .map(|handle| handle.flags().contains(OpenFlags::O_NONBLOCK))
-            .unwrap_or_default()
+            .is_some_and(|handle| handle.flags().contains(OpenFlags::O_NONBLOCK))
     }
 
     pub fn do_recv(&self, buf: &mut [u8]) -> Result<usize, FileSystemError> {
@@ -113,8 +109,7 @@ impl TcpSocket {
 
                 let mut socket = self.wq.block_on(&self.tcp, |tcp| {
                     tcp.as_ref()
-                        .map(|socket| !socket.recv_queue.is_empty())
-                        .unwrap_or(true)
+                        .map_or(true, |socket| !socket.recv_queue.is_empty())
                 })?;
 
                 if let Some(socket) = socket.as_mut() {
diff --git a/src/aero_kernel/src/socket/unix.rs b/src/aero_kernel/src/socket/unix.rs
@@ -28,7 +28,7 @@ use crate::arch::user_copy::UserRef;
 use crate::fs;
 use crate::fs::cache::DirCacheItem;
 use crate::fs::file_table::FileHandle;
-use crate::fs::inode::*;
+use crate::fs::inode::{DirEntry, FileType, INodeInterface, Metadata, PollFlags, PollTable};
 
 use crate::fs::{FileSystemError, Path};
 
@@ -342,7 +342,7 @@ impl INodeInterface for UnixSocket {
 
     fn accept(&self, address: Option<(VirtAddr, &mut u32)>) -> fs::Result<Arc<UnixSocket>> {
         let mut inner = self.wq.block_on(&self.inner, |e| {
-            e.state.queue().map(|x| !x.is_empty()).unwrap_or(false)
+            e.state.queue().is_some_and(|x| !x.is_empty())
         })?;
 
         let queue = inner
@@ -352,7 +352,7 @@ impl INodeInterface for UnixSocket {
 
         let peer = queue.pop().expect("UnixSocket::accept(): backlog is empty");
         let sock = Self::new();
-        sock.inner.lock_irq().address = inner.address.clone();
+        sock.inner.lock_irq().address.clone_from(&inner.address);
 
         {
             let mut sock_inner = sock.inner.lock_irq();
diff --git a/src/aero_kernel/src/userland/vm.rs b/src/aero_kernel/src/userland/vm.rs
diff --git a/src/aero_kernel/src/utils/buffer.rs b/src/aero_kernel/src/utils/buffer.rs
diff --git a/src/aero_kernel/src/utils/sync.rs b/src/aero_kernel/src/utils/sync.rs

Original file line number	Diff line number	Diff line change
`@@ -679,7 +679,9 @@ impl PciHeader {`
`679`	`679`
`680`	`680`	`// bit 0:true - the BAR is in memory`
`681`	`681`	`// bit 0:false - the BAR is in I/O`
`682`		`- if !bar.get_bit(0) {`
	`682`	`+ if bar.get_bit(0) {`
	`683`	`+ Some(Bar::IO(bar.get_bits(2..32)))`
	`684`	`+ } else {`
`683`	`685`	`let prefetchable = bar.get_bit(3);`
`684`	`686`	`let address = bar.get_bits(4..32) << 4;`
`685`	`687`
`@@ -727,8 +729,6 @@ impl PciHeader {`
`727`	`729`
`728`	`730`	`_ => None,`
`729`	`731`	`}`
`730`		`- } else {`
`731`		`- Some(Bar::IO(bar.get_bits(2..32)))`
`732`	`732`	`}`
`733`	`733`	`}`
`734`	`734`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ bitflags::bitflags! {`
`47`	`47`	`pub struct SerialPort(u16);`
`48`	`48`
`49`	`49`	`impl SerialPort {`
`50`		`- #[inline(always)]`
	`50`	`+ #[inline]`
`51`	`51`	`pub const fn new(port: u16) -> Self {`
`52`	`52`	`Self(port)`
`53`	`53`	`}`
`@@ -90,7 +90,7 @@ impl SerialPort {`
`90`	`90`
`91`	`91`	`fn wait_for_line_status(&self, line_status: LineStatus) {`
`92`	`92`	`while !self.line_status().contains(line_status) {`
`93`		`- core::hint::spin_loop()`
	`93`	`+ core::hint::spin_loop();`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ impl PathBuf {`
`138`	`138`	`self.as_mut_vec().truncate(0);`
`139`	`139`	`}`
`140`	`140`
`141`		`- let need_sep = self.0.chars().last().map(\|c\| c != '/').unwrap_or(false);`
	`141`	`+ let need_sep = self.0.chars().last().is_some_and(\|c\| c != '/');`
`142`	`142`
`143`	`143`	`// TODO: verbatim pahts need . and .. removed`
`144`	`144`