misc(kernel): cleanup

Signed-off-by: Anhad Singh <[email protected]>

Author: Andy-Python-Programmer

.vscode/settings.json

@@ -16,5 +16,5 @@
         "termios.h": "c",
         "termios-c_iflag.h": "c"
     },
-    // "rust-analyzer.check.command": "clippy",
+    "rust-analyzer.check.command": "clippy",
 }

src/aero_kernel/src/arch/x86_64/gdt.rs

@@ -337,7 +337,7 @@ pub fn init() {
         let gdt_size = gdt_ent_size * GDT_ENTRY_COUNT;
         let layout = Layout::from_size_align_unchecked(gdt_size, gdt_ent_align);
 
-        let ptr = alloc_zeroed(layout) as *mut GdtEntry;
+        let ptr = alloc_zeroed(layout).cast::<GdtEntry>();
         core::slice::from_raw_parts_mut::<GdtEntry>(ptr, GDT_ENTRY_COUNT)
     };
 

src/aero_kernel/src/arch/x86_64/task.rs

@@ -661,7 +661,7 @@ fn xsave(fpu: &mut FpuState) {
 
     use core::arch::x86_64::_fxsave64;
 
-    unsafe { _fxsave64(fpu as *mut FpuState as *mut _) }
+    unsafe { _fxsave64((fpu as *mut FpuState).cast()) }
 }
 
 fn xrstor(fpu: &FpuState) {
@@ -670,7 +670,7 @@ fn xrstor(fpu: &FpuState) {
     // options(nomem, nostack)); }
     use core::arch::x86_64::_fxrstor64;
 
-    unsafe { _fxrstor64(fpu as *const FpuState as *const _) }
+    unsafe { _fxrstor64((fpu as *const FpuState).cast()) }
 }
 
 /// Check out the module level documentation for more information.

src/aero_kernel/src/arch/x86_64/tls.rs

@@ -119,7 +119,7 @@ pub fn init() {
                 .map(|(name, _)| name)
                 .collect::<Vec<_>>()
         })
-        .unwrap_or(Vec::new());
+        .unwrap_or_default();
 
     CPU_INFO.lock().push(CpuInfo {
         cpuid: 0,

src/aero_kernel/src/main.rs

@@ -63,7 +63,7 @@
 #![no_std]
 #![no_main]
 #![reexport_test_harness_main = "test_main"]
-// #![warn(clippy::pedantic)]
+#![deny(clippy::ptr_as_ptr)]
 
 #[macro_use]
 extern crate aero_proc;

src/aero_kernel/src/mem/paging/frame.rs

@@ -299,31 +299,19 @@ impl GlobalFrameAllocator {
     fn new(memory_map_resp: &mut limine::response::MemoryMapResponse) -> Self {
         let memory_map = memory_map_resp.entries_mut();
 
-        // Find a memory map entry that is big enough to fit all of the items in
-        // range memory iter.
         let requested_size = (core::mem::size_of::<MemoryRange>() * memory_map.len()) as u64;
-        let mut region = None;
 
-        for i in 0..memory_map.len() {
-            let entry = &mut memory_map[i];
-
-            // Make sure that the memory map entry is marked as usable.
-            if entry.entry_type != memory_map::EntryType::USABLE {
-                continue;
-            }
-
-            // Found a big enough memory map entry.
-            if entry.length >= requested_size {
-                let base = entry.base;
-
-                entry.base += requested_size;
-                entry.length -= requested_size;
+        let entry = memory_map
+            .iter_mut()
+            .find(|entry| {
+                entry.entry_type == memory_map::EntryType::USABLE && entry.length >= requested_size
+            })
+            .expect("OOM");
 
-                region = Some(PhysAddr::new(base));
+        let region = PhysAddr::new(entry.base);
 
-                break;
-            }
-        }
+        entry.base += requested_size;
+        entry.length -= requested_size;
 
         let mut iter = memory_map_resp.entries().iter();
 
@@ -332,7 +320,7 @@ impl GlobalFrameAllocator {
             .expect("stivale2: unexpected end of the memory map");
 
         let ranges = unsafe {
-            let virt_addr = region.expect("stivale2: out of memory").as_hhdm_virt();
+            let virt_addr = region.as_hhdm_virt();
 
             core::slice::from_raw_parts_mut::<MemoryRange>(
                 virt_addr.as_mut_ptr(),

src/aero_kernel/src/mem/paging/mapper.rs

@@ -676,17 +676,14 @@ impl<'a, P: PageTableFrameMapping> Mapper<Size4KiB> for MappedPageTable<'a, P> {
         page: Page<Size4KiB>,
         flags: PageTableFlags,
     ) -> Result<MapperFlush<Size4KiB>, FlagUpdateError> {
-        let p4;
-
-        if self.level_5_paging_enabled {
+        let p4 = if self.level_5_paging_enabled {
             let p5 = &mut self.page_table;
 
-            p4 = self
-                .page_table_walker
-                .next_table_mut(&mut p5[page.p5_index()])?;
+            self.page_table_walker
+                .next_table_mut(&mut p5[page.p5_index()])?
         } else {
-            p4 = &mut self.page_table;
-        }
+            &mut self.page_table
+        };
 
         let p3 = self
             .page_table_walker

src/aero_kernel/src/rendy.rs

@@ -371,7 +371,9 @@ impl<'a> Inner<'a> {
 
             for x in xstart..xend {
                 let img_pixel = unsafe {
-                    (image.image.as_ptr()).add(fixedp6_to_int(img_x) * col_size + off) as *const u32
+                    (image.image.as_ptr())
+                        .add(fixedp6_to_int(img_x) * col_size + off)
+                        .cast::<u32>()
                 };
 
                 let i = blender(x, y, unsafe { *img_pixel });

src/aero_kernel/src/userland/vm.rs

@@ -65,7 +65,7 @@ fn parse_elf_header<'header>(file: DirCacheItem) -> Result<Header<'header>, ElfL
         .read_at(0, pt1_hdr_slice)
         .map_err(ElfLoadError::IOError)?;
 
-    let pt1_header: &'header _ = unsafe { &*(pt1_hdr_slice.as_ptr() as *const HeaderPt1) };
+    let pt1_header: &'header _ = unsafe { &*pt1_hdr_slice.as_ptr().cast::<HeaderPt1>() };
 
     // 2. Ensure that the header has the correct magic number:
     if pt1_header.magic != ELF_HEADER_MAGIC {
@@ -82,7 +82,7 @@ fn parse_elf_header<'header>(file: DirCacheItem) -> Result<Header<'header>, ElfL
                 .map_err(ElfLoadError::IOError)?;
 
             let pt2_header_ptr = pt2_hdr_slice.as_ptr();
-            let pt2_header: &'header _ = unsafe { &*(pt2_header_ptr as *const HeaderPt2_<P64>) };
+            let pt2_header: &'header _ = unsafe { &*pt2_header_ptr.cast::<HeaderPt2_<P64>>() };
 
             Ok(HeaderPt2::Header64(pt2_header))
         }
@@ -130,13 +130,13 @@ fn parse_program_header<'pheader>(
     match header.pt1.class() {
         // 3. Cast and return the 64-bit program header:
         Class::SixtyFour => {
-            let phdr: &'pheader _ = unsafe { &*(phdr_ptr as *const ProgramHeader64) };
+            let phdr: &'pheader _ = unsafe { &*phdr_ptr.cast::<ProgramHeader64>() };
             Ok(ProgramHeader::Ph64(phdr))
         }
 
         // 3. Cast and return the 32-bit program header:
         Class::ThirtyTwo => {
-            let phdr: &'pheader _ = unsafe { &*(phdr_ptr as *const ProgramHeader32) };
+            let phdr: &'pheader _ = unsafe { &*phdr_ptr.cast::<ProgramHeader32>() };
             Ok(ProgramHeader::Ph32(phdr))
         }
 

src/aero_kernel/src/utils/mod.rs

@@ -132,7 +132,7 @@ impl<T> PerCpu<T> {
         let cpu_count = get_cpu_count();
         let size = mem::size_of::<T>() * cpu_count;
 
-        let raw = unsafe { alloc_zeroed(Layout::from_size_align_unchecked(size, 8)) as *mut T };
+        let raw = unsafe { alloc_zeroed(Layout::from_size_align_unchecked(size, 8)).cast::<T>() };
 
         unsafe {
             for i in 0..cpu_count {