Rename PhysToVirt trait to PageTableFrameMapping

The new trait and method names better describe their purpose. Since the implementer must make sure that the returned pointer is valid and accessible, the trait is now unsafe to implement. Because of this requirement we also need to remove the generic implementation of this trait for closures.

Author: phil-opp

src/structures/paging/mapper/mapped_page_table.rs

@@ -14,26 +14,26 @@ use crate::structures::paging::{
 /// memory are possible too, as long as they can be calculated as an `PhysAddr` to
 /// `VirtAddr` closure.
 #[derive(Debug)]
-pub struct MappedPageTable<'a, P: PhysToVirt> {
+pub struct MappedPageTable<'a, P: PageTableFrameMapping> {
     page_table_walker: PageTableWalker<P>,
     level_4_table: &'a mut PageTable,
 }
 
-impl<'a, P: PhysToVirt> MappedPageTable<'a, P> {
+impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
     /// Creates a new `MappedPageTable` that uses the passed closure for converting virtual
     /// to physical addresses.
     ///
     /// ## Safety
     ///
-    /// This function is unsafe because the caller must guarantee that the passed `phys_to_virt`
+    /// This function is unsafe because the caller must guarantee that the passed `page_table_frame_mapping`
     /// closure is correct. Also, the passed `level_4_table` must point to the level 4 page table
     /// of a valid page table hierarchy. Otherwise this function might break memory safety, e.g.
     /// by writing to an illegal memory location.
     #[inline]
-    pub unsafe fn new(level_4_table: &'a mut PageTable, phys_to_virt: P) -> Self {
+    pub unsafe fn new(level_4_table: &'a mut PageTable, page_table_frame_mapping: P) -> Self {
         Self {
             level_4_table,
-            page_table_walker: PageTableWalker::new(phys_to_virt),
+            page_table_walker: PageTableWalker::new(page_table_frame_mapping),
         }
     }
 
@@ -142,7 +142,7 @@ impl<'a, P: PhysToVirt> MappedPageTable<'a, P> {
     }
 }
 
-impl<'a, P: PhysToVirt> Mapper<Size1GiB> for MappedPageTable<'a, P> {
+impl<'a, P: PageTableFrameMapping> Mapper<Size1GiB> for MappedPageTable<'a, P> {
     #[inline]
     unsafe fn map_to_with_table_flags<A>(
         &mut self,
@@ -250,7 +250,7 @@ impl<'a, P: PhysToVirt> Mapper<Size1GiB> for MappedPageTable<'a, P> {
     }
 }
 
-impl<'a, P: PhysToVirt> Mapper<Size2MiB> for MappedPageTable<'a, P> {
+impl<'a, P: PageTableFrameMapping> Mapper<Size2MiB> for MappedPageTable<'a, P> {
     #[inline]
     unsafe fn map_to_with_table_flags<A>(
         &mut self,
@@ -378,7 +378,7 @@ impl<'a, P: PhysToVirt> Mapper<Size2MiB> for MappedPageTable<'a, P> {
     }
 }
 
-impl<'a, P: PhysToVirt> Mapper<Size4KiB> for MappedPageTable<'a, P> {
+impl<'a, P: PageTableFrameMapping> Mapper<Size4KiB> for MappedPageTable<'a, P> {
     #[inline]
     unsafe fn map_to_with_table_flags<A>(
         &mut self,
@@ -522,7 +522,7 @@ impl<'a, P: PhysToVirt> Mapper<Size4KiB> for MappedPageTable<'a, P> {
     }
 }
 
-impl<'a, P: PhysToVirt> Translate for MappedPageTable<'a, P> {
+impl<'a, P: PageTableFrameMapping> Translate for MappedPageTable<'a, P> {
     #[allow(clippy::inconsistent_digit_grouping)]
     fn translate(&self, addr: VirtAddr) -> TranslateResult {
         let p4 = &self.level_4_table;
@@ -585,14 +585,16 @@ impl<'a, P: PhysToVirt> Translate for MappedPageTable<'a, P> {
 }
 
 #[derive(Debug)]
-struct PageTableWalker<P: PhysToVirt> {
-    phys_to_virt: P,
+struct PageTableWalker<P: PageTableFrameMapping> {
+    page_table_frame_mapping: P,
 }
 
-impl<P: PhysToVirt> PageTableWalker<P> {
+impl<P: PageTableFrameMapping> PageTableWalker<P> {
     #[inline]
-    pub unsafe fn new(phys_to_virt: P) -> Self {
-        Self { phys_to_virt }
+    pub unsafe fn new(page_table_frame_mapping: P) -> Self {
+        Self {
+            page_table_frame_mapping,
+        }
     }
 
     /// Internal helper function to get a reference to the page table of the next level.
@@ -605,7 +607,9 @@ impl<P: PhysToVirt> PageTableWalker<P> {
         &self,
         entry: &'b PageTableEntry,
     ) -> Result<&'b PageTable, PageTableWalkError> {
-        let page_table_ptr = self.phys_to_virt.phys_to_virt(entry.frame()?);
+        let page_table_ptr = self
+            .page_table_frame_mapping
+            .frame_to_pointer(entry.frame()?);
         let page_table: &PageTable = unsafe { &*page_table_ptr };
 
         Ok(page_table)
@@ -621,7 +625,9 @@ impl<P: PhysToVirt> PageTableWalker<P> {
         &self,
         entry: &'b mut PageTableEntry,
     ) -> Result<&'b mut PageTable, PageTableWalkError> {
-        let page_table_ptr = self.phys_to_virt.phys_to_virt(entry.frame()?);
+        let page_table_ptr = self
+            .page_table_frame_mapping
+            .frame_to_pointer(entry.frame()?);
         let page_table: &mut PageTable = unsafe { &mut *page_table_ptr };
 
         Ok(page_table)
@@ -758,21 +764,16 @@ impl From<PageTableWalkError> for TranslateError {
     }
 }
 
-/// Trait for converting a physical address to a virtual one.
+/// Provides a virtual address mapping for physical page table frames.
 ///
 /// This only works if the physical address space is somehow mapped to the virtual
 /// address space, e.g. at an offset.
-pub trait PhysToVirt {
+///
+/// ## Safety
+///
+/// This trait is unsafe to implement because the implementer must ensure that
+/// `frame_to_pointer` returns a valid page table pointer for any given physical frame.
+pub unsafe trait PageTableFrameMapping {
     /// Translate the given physical frame to a virtual page table pointer.
-    fn phys_to_virt(&self, phys_frame: PhysFrame) -> *mut PageTable;
-}
-
-impl<T> PhysToVirt for T
-where
-    T: Fn(PhysFrame) -> *mut PageTable,
-{
-    #[inline]
-    fn phys_to_virt(&self, phys_frame: PhysFrame) -> *mut PageTable {
-        self(phys_frame)
-    }
+    fn frame_to_pointer(&self, frame: PhysFrame) -> *mut PageTable;
 }

src/structures/paging/mapper/mod.rs

@@ -1,6 +1,6 @@
 //! Abstractions for reading and modifying the mapping of pages.
 
-pub use self::mapped_page_table::{MappedPageTable, PhysToVirt};
+pub use self::mapped_page_table::{MappedPageTable, PageTableFrameMapping};
 #[cfg(target_pointer_width = "64")]
 pub use self::offset_page_table::OffsetPageTable;
 #[cfg(feature = "instructions")]

src/structures/paging/mapper/offset_page_table.rs

@@ -48,11 +48,9 @@ struct PhysOffset {
     offset: VirtAddr,
 }
 
-impl PhysToVirt for PhysOffset {
-    #[inline]
-    fn phys_to_virt(&self, frame: PhysFrame) -> *mut PageTable {
-        let phys = frame.start_address().as_u64();
-        let virt = self.offset + phys;
+unsafe impl PageTableFrameMapping for PhysOffset {
+    fn frame_to_pointer(&self, frame: PhysFrame) -> *mut PageTable {
+        let virt = self.offset + frame.start_address().as_u64();
         virt.as_mut_ptr()
     }
 }