fix warnings

Author: xor-bits

crates/arch-x86_64/src/vmm.rs

@@ -22,12 +22,12 @@
 //! User and kernel stack spaces are split into stacks with the size of [`VIRT_STACK_SIZE`].
 
 use alloc::collections::BTreeMap;
-use core::{cmp::Ordering, ops::Range};
+use core::ops::Range;
 
 use hyperion_log::*;
 use hyperion_mem::{
-    from_higher_half, is_higher_half,
-    pmm::{self, PageFrame},
+    from_higher_half,
+    pmm::{self},
     to_higher_half,
     vmm::{Handled, NotHandled, PageFaultResult, PageMapImpl, Privilege},
 };
@@ -36,12 +36,9 @@ use x86_64::{
     instructions::tlb,
     registers::control::{Cr3, Cr3Flags},
     structures::paging::{
-        mapper::{
-            MapToError, MappedFrame, MapperFlush, MapperFlushAll, TranslateResult, UnmapError,
-        },
+        mapper::{MapToError, MappedFrame, MapperFlush, MapperFlushAll},
         page_table::{FrameError, PageTableEntry},
-        MappedPageTable, Mapper, OffsetPageTable, Page, PageSize, PageTable, PageTableFlags,
-        PhysFrame, Size1GiB, Size2MiB, Size4KiB, Translate,
+        Page, PageSize, PageTable, PageTableFlags, PhysFrame, Size1GiB, Size2MiB, Size4KiB,
     },
     PhysAddr, VirtAddr,
 };
@@ -141,7 +138,7 @@ fn page_fault_2mib(entry: &mut PageTableEntry, addr: VirtAddr) -> PageFaultResul
 }
 
 fn page_fault_4kib(entry: &mut PageTableEntry, addr: VirtAddr) -> PageFaultResult {
-    let mut frame;
+    let frame;
     let mut flags = entry.flags();
 
     if flags.contains(COW) {
@@ -172,10 +169,11 @@ fn alloc_table() -> PhysFrame {
     PhysFrame::<Size4KiB>::from_start_address(frame.physical_addr()).unwrap()
 }
 
-fn free_table(f: PhysFrame) {
+// FIXME: vmm dealloc
+/* fn free_table(f: PhysFrame) {
     let frame = unsafe { PageFrame::new(f.start_address(), 1) };
     pmm::PFA.free(frame)
-}
+} */
 
 //
 
@@ -1033,7 +1031,7 @@ impl LockedPageMap {
         };
 
         let l1e = &l1[v_addr.p1_index()];
-        let phys = match l1e.frame() {
+        match l1e.frame() {
             Ok(p) => p,
             Err(FrameError::FrameNotPresent) => return None,
             Err(FrameError::HugeFrame) => unreachable!("huge page at lvl 1"),
@@ -1311,108 +1309,3 @@ pub enum TryMapError<T: PageSize> {
     AlreadyMapped,
     NotMapped,
 }
-
-#[derive(Debug)]
-pub enum TryUnmapError<T: PageSize> {
-    Overflow,
-    NotAligned,
-    MapToError(MapToError<T>),
-    WrongSize,
-    AlreadyMapped,
-}
-
-fn try_map_sized<T>(
-    table: &mut OffsetPageTable,
-    start: VirtAddr,
-    end: VirtAddr,
-    p_addr: PhysAddr,
-    flags: PageTableFlags,
-) -> Result<(), TryMapError<T>>
-where
-    T: PageSize,
-    for<'a> OffsetPageTable<'a>: Mapper<T>,
-{
-    let Some(mapping_end) = start.as_u64().checked_add(T::SIZE - 1) else {
-        return Err(TryMapError::Overflow);
-    };
-
-    if mapping_end > end.as_u64() {
-        return Err(TryMapError::Overflow);
-    }
-
-    if !start.is_aligned(T::SIZE) || !p_addr.is_aligned(T::SIZE) {
-        return Err(TryMapError::NotAligned);
-    }
-
-    let page = Page::<T>::containing_address(start);
-    let frame = PhysFrame::<T>::containing_address(p_addr);
-
-    let result = unsafe {
-        table.map_to_with_table_flags(
-            page,
-            frame,
-            flags,
-            (flags & (PageTableFlags::PRESENT | PageTableFlags::USER_ACCESSIBLE))
-                | PageTableFlags::WRITABLE,
-            &mut Pfa,
-        )
-    };
-
-    if let Err(MapToError::PageAlreadyMapped(old_frame)) = result {
-        if old_frame == frame {
-            return Ok(());
-        }
-    }
-
-    result.map_err(|err| TryMapError::MapToError(err))?.flush();
-
-    /* hyperion_log::debug!("mapped 1GiB at 0x{:016x}", start);
-    crash_after_nth(10); */
-
-    Ok(())
-}
-
-fn try_unmap_sized<T>(
-    table: &mut OffsetPageTable,
-    start: VirtAddr,
-    _end: VirtAddr,
-) -> Result<(), TryMapError<T>>
-where
-    T: PageSize,
-    for<'a> OffsetPageTable<'a>: Mapper<T>,
-{
-    let Some(_mapping_end) = start.as_u64().checked_add(T::SIZE - 1) else {
-        return Err(TryMapError::Overflow);
-    };
-
-    /* if mapping_end > end.as_u64() {
-        return Err(TryMapSizedError::Overflow);
-    } */
-
-    if !start.is_aligned(T::SIZE) {
-        return Err(TryMapError::NotAligned);
-    }
-
-    let page = Page::<T>::containing_address(start);
-
-    match table.unmap(page) {
-        Ok((_, ok)) => {
-            ok.flush();
-            Ok(())
-        }
-        Err(UnmapError::PageNotMapped) => {
-            // hyperion_log::debug!("already not mapped");
-            Ok(())
-        }
-        Err(UnmapError::ParentEntryHugePage) => Err(TryMapError::WrongSize),
-        Err(_err) => panic!("{_err:?}"),
-    }
-}
-
-fn v_addr_checked_add(addr: VirtAddr, rhs: u64) -> Option<VirtAddr> {
-    VirtAddr::try_new(addr.as_u64().checked_add(rhs)?).ok()
-}
-
-fn p_addr_checked_add(addr: PhysAddr, rhs: u64) -> Option<PhysAddr> {
-    PhysAddr::try_new(addr.as_u64().checked_add(rhs)?).ok()
-}

crates/loader/src/lib.rs

@@ -21,7 +21,7 @@ use elf::{
 use elf_wrap::*;
 use hyperion_arch::{syscall, vmm::PageMap};
 use hyperion_log::*;
-use hyperion_mem::{is_higher_half, to_higher_half, vmm::PageMapImpl};
+use hyperion_mem::{is_higher_half, vmm::PageMapImpl};
 use hyperion_scheduler::{process, task, task::Process};
 use x86_64::{structures::paging::PageTableFlags, VirtAddr};
 
@@ -111,7 +111,6 @@ impl<'a> Loader<'a> {
         let v_addr = VirtAddr::new(segment.p_vaddr)
             .align_down(align)
             .align_down(0x1000u64);
-        let align_down_offs = segment.p_vaddr - v_addr.as_u64();
         let v_end = (VirtAddr::new(segment.p_vaddr) + segment.p_memsz).align_up(0x1000u64);
         let v_size = v_end - v_addr;
 
@@ -152,9 +151,8 @@ impl<'a> Loader<'a> {
             unsafe { slice::from_raw_parts_mut(v_addr.as_mut_ptr(), v_size as usize) };
 
         // fill segment_alloc with segment_data and pad the end with null bytes
-        let (segment_alloc_align_pad, segment_alloc_virtual) =
-            segment_alloc.split_at_mut(align_down_offs as usize);
-        let (segment_alloc_data, segment_alloc_zeros) =
+        let (_, segment_alloc_virtual) = segment_alloc.split_at_mut(align_down_offs as usize);
+        let (segment_alloc_data, _) =
             segment_alloc_virtual.split_at_mut(segment_alloc_virtual.len().min(segment_data.len()));
 
         // the rust compiler will convert these to u64 or even vectors
@@ -203,9 +201,7 @@ impl<'a> Loader<'a> {
         let v_addr = VirtAddr::new(segment.p_vaddr)
             .align_down(align)
             .align_down(0x1000u64);
-        let align_down_offs = segment.p_vaddr - v_addr.as_u64();
         let v_end = (VirtAddr::new(segment.p_vaddr) + segment.p_memsz).align_up(0x1000u64);
-        let v_size = v_end - v_addr;
         let flags = Self::flags(segment.p_flags);
 
         // println!("remap as {flags:?}");

crates/scheduler/src/task.rs

@@ -298,12 +298,6 @@ impl Process {
     }
 
     pub fn free(&self, n_pages: usize, ptr: VirtAddr) -> Result<(), FreeErr> {
-        let mut bitmap = self.allocs.bitmap();
-
-        let Some(palloc) = self.address_space.page_map.virt_to_phys(ptr) else {
-            return Err(FreeErr::InvalidAddr);
-        };
-
         if !self
             .address_space
             .page_map