feat(mapper): make PhysOffset public

Author: mkroening

src/structures/paging/mapper/mod.rs

@@ -2,7 +2,7 @@
 
 pub use self::mapped_page_table::{MappedPageTable, PageTableFrameMapping};
 #[cfg(target_pointer_width = "64")]
-pub use self::offset_page_table::OffsetPageTable;
+pub use self::offset_page_table::{OffsetPageTable, PhysOffset};
 #[cfg(all(feature = "instructions", target_arch = "x86_64"))]
 pub use self::recursive_page_table::{InvalidPageTable, RecursivePageTable};
 

src/structures/paging/mapper/offset_page_table.rs

@@ -27,7 +27,7 @@ impl<'a> OffsetPageTable<'a> {
     /// by writing to an illegal memory location.
     #[inline]
     pub unsafe fn new(level_4_table: &'a mut PageTable, phys_offset: VirtAddr) -> Self {
-        let phys_offset = PhysOffset { phys_offset };
+        let phys_offset = unsafe { PhysOffset::new(phys_offset) };
         Self {
             inner: unsafe { MappedPageTable::new(level_4_table, phys_offset) },
         }
@@ -45,15 +45,43 @@ impl<'a> OffsetPageTable<'a> {
 
     /// Returns the offset used for converting virtual to physical addresses.
     pub fn phys_offset(&self) -> VirtAddr {
-        self.inner.page_table_frame_mapping().phys_offset
+        self.inner.page_table_frame_mapping().phys_offset()
     }
 }
 
+/// A [`PageTableFrameMapping`] implementation that requires that the complete physical memory is mapped at some
+/// offset in the virtual address space.
 #[derive(Debug)]
-struct PhysOffset {
+pub struct PhysOffset {
     phys_offset: VirtAddr,
 }
 
+impl PhysOffset {
+    /// Creates a new `PhysOffset` that uses the given offset for converting virtual
+    /// to physical addresses.
+    ///
+    /// The complete physical memory must be mapped in the virtual address space starting at
+    /// address `phys_offset`. This means that for example physical address `0x5000` can be
+    /// accessed through virtual address `phys_offset + 0x5000`. This mapping is required because
+    /// the mapper needs to access page tables, which are not mapped into the virtual address
+    /// space by default.
+    ///
+    /// ## Safety
+    ///
+    /// This function is unsafe because the caller must guarantee that the passed `phys_offset`
+    /// is correct. Otherwise this function might break memory safety, e.g. by writing to an
+    /// illegal memory location.
+    #[inline]
+    pub unsafe fn new(phys_offset: VirtAddr) -> Self {
+        Self { phys_offset }
+    }
+
+    /// Returns the offset used for converting virtual to physical addresses.
+    pub fn phys_offset(&self) -> VirtAddr {
+        self.phys_offset
+    }
+}
+
 unsafe impl PageTableFrameMapping for PhysOffset {
     fn frame_to_pointer(&self, frame: PhysFrame) -> *mut PageTable {
         let virt = self.phys_offset + frame.start_address().as_u64();

src/structures/paging/mod.rs

@@ -6,13 +6,13 @@ pub use self::frame::PhysFrame;
 pub use self::frame_alloc::{FrameAllocator, FrameDeallocator};
 #[doc(no_inline)]
 pub use self::mapper::MappedPageTable;
-#[cfg(target_pointer_width = "64")]
-#[doc(no_inline)]
-pub use self::mapper::OffsetPageTable;
 #[cfg(all(feature = "instructions", target_arch = "x86_64"))]
 #[doc(no_inline)]
 pub use self::mapper::RecursivePageTable;
 pub use self::mapper::{Mapper, Translate};
+#[cfg(target_pointer_width = "64")]
+#[doc(no_inline)]
+pub use self::mapper::{OffsetPageTable, PhysOffset};
 pub use self::page::{Page, PageSize, Size1GiB, Size2MiB, Size4KiB};
 pub use self::page_table::{PageOffset, PageTable, PageTableFlags, PageTableIndex};