Remove From<PhysFrameRange> implementations for x86_64 FrameRange

Author: phil-opp

src/bootinfo/mod.rs

@@ -42,26 +42,3 @@ impl BootInfo {
 extern "C" {
     fn _improper_ctypes_check(_boot_info: BootInfo);
 }
-
-use x86_64::{
-    structures::paging::{PhysFrame, PhysFrameRange},
-    PhysAddr,
-};
-
-impl From<FrameRange> for PhysFrameRange {
-    fn from(range: FrameRange) -> Self {
-        PhysFrameRange {
-            start: PhysFrame::from_start_address(PhysAddr::new(range.start_addr())).unwrap(),
-            end: PhysFrame::from_start_address(PhysAddr::new(range.end_addr())).unwrap(),
-        }
-    }
-}
-
-impl From<PhysFrameRange> for FrameRange {
-    fn from(range: PhysFrameRange) -> Self {
-        FrameRange::new(
-            range.start.start_address().as_u64(),
-            range.end.start_address().as_u64(),
-        )
-    }
-}

src/frame_allocator.rs

@@ -1,5 +1,6 @@
 use bootloader::bootinfo::{MemoryMap, MemoryRegion, MemoryRegionType};
 use x86_64::structures::paging::{PhysFrame, PhysFrameRange};
+use super::{frame_range, phys_frame_range};
 
 pub(crate) struct FrameAllocator<'a> {
     pub memory_map: &'a mut MemoryMap,
@@ -16,7 +17,7 @@ impl<'a> FrameAllocator<'a> {
                         && next.region_type == MemoryRegionType::Usable
                         && !next.range.is_empty()
                     {
-                        let frame = PhysFrameRange::from(region.range).end;
+                        let frame = phys_frame_range(region.range).end;
                         region.range.end_frame_number += 1;
                         iter.next().unwrap().range.start_frame_number += 1;
                         return Some(frame);
@@ -37,7 +38,7 @@ impl<'a> FrameAllocator<'a> {
                     continue;
                 }
 
-                let frame = PhysFrameRange::from(region.range).start;
+                let frame = phys_frame_range(region.range).start;
                 region.range.start_frame_number += 1;
                 return Some((frame, PhysFrame::range(frame, frame + 1)));
             }
@@ -53,7 +54,7 @@ impl<'a> FrameAllocator<'a> {
 
         if let Some((frame, range)) = result {
             self.memory_map.add_region(MemoryRegion {
-                range: range.into(),
+                range: frame_range(range),
                 region_type,
             });
             Some(frame)

src/main.rs

@@ -8,13 +8,13 @@
 #![no_std]
 #![no_main]
 
-use bootloader::bootinfo::BootInfo;
+use bootloader::bootinfo::{BootInfo, FrameRange};
 use core::panic::PanicInfo;
 use core::{mem, slice};
 use fixedvec::alloc_stack;
 use usize_conversions::usize_from;
 use x86_64::structures::paging::{Mapper, RecursivePageTable};
-use x86_64::structures::paging::{Page, PageTableFlags, PhysFrame, Size2MiB};
+use x86_64::structures::paging::{Page, PageTableFlags, PhysFrame, PhysFrameRange, Size2MiB};
 use x86_64::ux::u9;
 use x86_64::{PhysAddr, VirtAddr};
 
@@ -157,31 +157,31 @@ fn load_elf(
     {
         let zero_frame: PhysFrame = PhysFrame::from_start_address(PhysAddr::new(0)).unwrap();
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: PhysFrame::range(zero_frame, zero_frame + 1).into(),
+            range: frame_range(PhysFrame::range(zero_frame, zero_frame + 1)),
             region_type: MemoryRegionType::FrameZero,
         });
         let bootloader_start_frame = PhysFrame::containing_address(bootloader_start);
         let bootloader_end_frame = PhysFrame::containing_address(bootloader_end - 1u64);
         let bootloader_memory_area =
             PhysFrame::range(bootloader_start_frame, bootloader_end_frame + 1);
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: bootloader_memory_area.into(),
+            range: frame_range(bootloader_memory_area),
             region_type: MemoryRegionType::Bootloader,
         });
         let kernel_start_frame = PhysFrame::containing_address(kernel_start.phys());
         let kernel_end_frame =
             PhysFrame::containing_address(kernel_start.phys() + kernel_size - 1u64);
         let kernel_memory_area = PhysFrame::range(kernel_start_frame, kernel_end_frame + 1);
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: kernel_memory_area.into(),
+            range: frame_range(kernel_memory_area),
             region_type: MemoryRegionType::Kernel,
         });
         let page_table_start_frame = PhysFrame::containing_address(page_table_start);
         let page_table_end_frame = PhysFrame::containing_address(page_table_end - 1u64);
         let page_table_memory_area =
             PhysFrame::range(page_table_start_frame, page_table_end_frame + 1);
         frame_allocator.mark_allocated_region(MemoryRegion {
-            range: page_table_memory_area.into(),
+            range: frame_range(page_table_memory_area),
             region_type: MemoryRegionType::PageTable,
         });
     }
@@ -282,3 +282,17 @@ pub extern "C" fn eh_personality() {
 pub extern "C" fn _Unwind_Resume() {
     loop {}
 }
+
+fn phys_frame_range(range: FrameRange) -> PhysFrameRange {
+    PhysFrameRange {
+        start: PhysFrame::from_start_address(PhysAddr::new(range.start_addr())).unwrap(),
+        end: PhysFrame::from_start_address(PhysAddr::new(range.end_addr())).unwrap(),
+    }
+}
+
+fn frame_range(range: PhysFrameRange) -> FrameRange {
+    FrameRange::new(
+        range.start.start_address().as_u64(),
+        range.end.start_address().as_u64(),
+    )
+}