Merge pull request #214 from rust-osdev/rename-phys-to-virt

Rename `PhysToVirt` trait to `PageTableFrameMapping`

Author: phil-opp

Changelog.md

@@ -2,6 +2,7 @@
 
 - **Breaking:** Also return flags for `MapperAllSizes::translate()` ([#207](https://github.com/rust-osdev/x86_64/pull/207))
 - **Breaking:** Restructure the `TranslateResult` type and create separate `Translate` trait ([#211](https://github.com/rust-osdev/x86_64/pull/211))
+- **Breaking:** Rename `PhysToVirt` trait to `PageTableFrameMapping` ([#214](https://github.com/rust-osdev/x86_64/pull/214))
 - **Breaking:** Use custom error types instead of `()` ([#199](https://github.com/rust-osdev/x86_64/pull/199))
 - **Breaking:** Remove deprecated items
   - `UnusedPhysFrame`

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()
     }
 }