Revert "Add new UnsafePhysFrame type and use it in Mapper::map_to"

This reverts commit 0c8756f.

src/structures/paging/frame_alloc.rs

@@ -1,54 +1,18 @@
 //! Traits for abstracting away frame allocation and deallocation.
 
-use crate::structures::paging::{PageSize, PhysFrame, Size4KiB};
-use core::ops::{Deref, DerefMut};
+use crate::structures::paging::{PageSize, PhysFrame};
 
 /// A trait for types that can allocate a frame of memory.
 ///
 /// This trait is unsafe to implement because the implementer must guarantee that
 /// the `allocate_frame` method returns only unique unused frames.
 pub unsafe trait FrameAllocator<S: PageSize> {
     /// Allocate a frame of the appropriate size and return it if possible.
-    fn allocate_frame(&mut self) -> Option<UnusedPhysFrame<S>>;
+    fn allocate_frame(&mut self) -> Option<PhysFrame<S>>;
 }
 
 /// A trait for types that can deallocate a frame of memory.
 pub trait FrameDeallocator<S: PageSize> {
     /// Deallocate the given frame of memory.
-    fn deallocate_frame(&mut self, frame: UnusedPhysFrame<S>);
-}
-
-/// Represents a physical frame that is not used for any mapping.
-#[derive(Debug)]
-pub struct UnusedPhysFrame<S: PageSize = Size4KiB>(PhysFrame<S>);
-
-impl<S: PageSize> UnusedPhysFrame<S> {
-    /// Creates a new UnusedPhysFrame from the given frame.
-    ///
-    /// ## Safety
-    ///
-    /// This method is unsafe because the caller must guarantee
-    /// that the given frame is unused.
-    pub unsafe fn new(frame: PhysFrame<S>) -> Self {
-        Self(frame)
-    }
-
-    /// Returns the physical frame as `PhysFrame` type.
-    pub fn frame(self) -> PhysFrame<S> {
-        self.0
-    }
-}
-
-impl<S: PageSize> Deref for UnusedPhysFrame<S> {
-    type Target = PhysFrame<S>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<S: PageSize> DerefMut for UnusedPhysFrame<S> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
+    fn deallocate_frame(&mut self, frame: PhysFrame<S>);
 }

src/structures/paging/mapper/mapped_page_table.rs

@@ -41,7 +41,7 @@ impl<'a, P: PhysToVirt> MappedPageTable<'a, P> {
     fn map_to_1gib<A>(
         &mut self,
         page: Page<Size1GiB>,
-        frame: UnusedPhysFrame<Size1GiB>,
+        frame: PhysFrame<Size1GiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
@@ -66,7 +66,7 @@ impl<'a, P: PhysToVirt> MappedPageTable<'a, P> {
     fn map_to_2mib<A>(
         &mut self,
         page: Page<Size2MiB>,
-        frame: UnusedPhysFrame<Size2MiB>,
+        frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
@@ -94,7 +94,7 @@ impl<'a, P: PhysToVirt> MappedPageTable<'a, P> {
     fn map_to_4kib<A>(
         &mut self,
         page: Page<Size4KiB>,
-        frame: UnusedPhysFrame<Size4KiB>,
+        frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
@@ -115,17 +115,17 @@ impl<'a, P: PhysToVirt> MappedPageTable<'a, P> {
         if !p1[page.p1_index()].is_unused() {
             return Err(MapToError::PageAlreadyMapped(frame));
         }
-        p1[page.p1_index()].set_frame(frame.frame(), flags);
+        p1[page.p1_index()].set_frame(frame, flags);
 
         Ok(MapperFlush::new(page))
     }
 }
 
 impl<'a, P: PhysToVirt> Mapper<Size1GiB> for MappedPageTable<'a, P> {
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size1GiB>,
-        frame: UnusedPhysFrame<Size1GiB>,
+        frame: PhysFrame<Size1GiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
@@ -195,10 +195,10 @@ impl<'a, P: PhysToVirt> Mapper<Size1GiB> for MappedPageTable<'a, P> {
 }
 
 impl<'a, P: PhysToVirt> Mapper<Size2MiB> for MappedPageTable<'a, P> {
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size2MiB>,
-        frame: UnusedPhysFrame<Size2MiB>,
+        frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
@@ -276,10 +276,10 @@ impl<'a, P: PhysToVirt> Mapper<Size2MiB> for MappedPageTable<'a, P> {
 }
 
 impl<'a, P: PhysToVirt> Mapper<Size4KiB> for MappedPageTable<'a, P> {
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size4KiB>,
-        frame: UnusedPhysFrame<Size4KiB>,
+        frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
@@ -465,10 +465,7 @@ impl<P: PhysToVirt> PageTableWalker<P> {
 
         if entry.is_unused() {
             if let Some(frame) = allocator.allocate_frame() {
-                entry.set_frame(
-                    frame.frame(),
-                    PageTableFlags::PRESENT | PageTableFlags::WRITABLE,
-                );
+                entry.set_frame(frame, PageTableFlags::PRESENT | PageTableFlags::WRITABLE);
                 created = true;
             } else {
                 return Err(PageTableCreateError::FrameAllocationFailed);

src/structures/paging/mapper/mod.rs

@@ -5,9 +5,8 @@ pub use self::mapped_page_table::{MappedPageTable, PhysToVirt};
 pub use self::{offset_page_table::OffsetPageTable, recursive_page_table::RecursivePageTable};
 
 use crate::structures::paging::{
-    frame_alloc::{FrameAllocator, UnusedPhysFrame},
-    page_table::PageTableFlags,
-    Page, PageSize, PhysFrame, Size1GiB, Size2MiB, Size4KiB,
+    frame_alloc::FrameAllocator, page_table::PageTableFlags, Page, PageSize, PhysFrame, Size1GiB,
+    Size2MiB, Size4KiB,
 };
 use crate::{PhysAddr, VirtAddr};
 
@@ -83,10 +82,13 @@ pub trait Mapper<S: PageSize> {
     ///
     /// This function might need additional physical frames to create new page tables. These
     /// frames are allocated from the `allocator` argument. At most three frames are required.
-    fn map_to<A>(
+    ///
+    /// This function is unsafe because the caller must guarantee that passed `frame` is
+    /// unused, i.e. not used for any other mappings.
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<S>,
-        frame: UnusedPhysFrame<S>,
+        frame: PhysFrame<S>,
         flags: PageTableFlags,
         frame_allocator: &mut A,
     ) -> Result<MapperFlush<S>, MapToError<S>>
@@ -116,11 +118,12 @@ pub trait Mapper<S: PageSize> {
     ///
     /// ## Safety
     ///
-    /// TODO: Should this function be safe?
+    /// This function is unsafe because the caller must guarantee that the passed `frame` is
+    /// unused, i.e. not used for any other mappings.
     #[inline]
     unsafe fn identity_map<A>(
         &mut self,
-        frame: UnusedPhysFrame<S>,
+        frame: PhysFrame<S>,
         flags: PageTableFlags,
         frame_allocator: &mut A,
     ) -> Result<MapperFlush<S>, MapToError<S>>

src/structures/paging/mapper/offset_page_table.rs

@@ -53,10 +53,10 @@ impl PhysToVirt for PhysOffset {
 // delegate all trait implementations to inner
 
 impl<'a> Mapper<Size1GiB> for OffsetPageTable<'a> {
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size1GiB>,
-        frame: UnusedPhysFrame<Size1GiB>,
+        frame: PhysFrame<Size1GiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
@@ -91,10 +91,10 @@ impl<'a> Mapper<Size1GiB> for OffsetPageTable<'a> {
 
 impl<'a> Mapper<Size2MiB> for OffsetPageTable<'a> {
     #[inline]
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size2MiB>,
-        frame: UnusedPhysFrame<Size2MiB>,
+        frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
@@ -129,10 +129,10 @@ impl<'a> Mapper<Size2MiB> for OffsetPageTable<'a> {
 
 impl<'a> Mapper<Size4KiB> for OffsetPageTable<'a> {
     #[inline]
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size4KiB>,
-        frame: UnusedPhysFrame<Size4KiB>,
+        frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>

src/structures/paging/mapper/recursive_page_table.rs

@@ -113,7 +113,7 @@ impl<'a> RecursivePageTable<'a> {
 
             if entry.is_unused() {
                 if let Some(frame) = allocator.allocate_frame() {
-                    entry.set_frame(frame.frame(), Flags::PRESENT | Flags::WRITABLE);
+                    entry.set_frame(frame, Flags::PRESENT | Flags::WRITABLE);
                     created = true;
                 } else {
                     return Err(MapToError::FrameAllocationFailed);
@@ -141,7 +141,7 @@ impl<'a> RecursivePageTable<'a> {
     fn map_to_1gib<A>(
         &mut self,
         page: Page<Size1GiB>,
-        frame: UnusedPhysFrame<Size1GiB>,
+        frame: PhysFrame<Size1GiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
@@ -167,7 +167,7 @@ impl<'a> RecursivePageTable<'a> {
     fn map_to_2mib<A>(
         &mut self,
         page: Page<Size2MiB>,
-        frame: UnusedPhysFrame<Size2MiB>,
+        frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
@@ -196,7 +196,7 @@ impl<'a> RecursivePageTable<'a> {
     fn map_to_4kib<A>(
         &mut self,
         page: Page<Size4KiB>,
-        frame: UnusedPhysFrame<Size4KiB>,
+        frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
@@ -217,17 +217,17 @@ impl<'a> RecursivePageTable<'a> {
         if !p1[page.p1_index()].is_unused() {
             return Err(MapToError::PageAlreadyMapped(frame));
         }
-        p1[page.p1_index()].set_frame(frame.frame(), flags);
+        p1[page.p1_index()].set_frame(frame, flags);
 
         Ok(MapperFlush::new(page))
     }
 }
 
 impl<'a> Mapper<Size1GiB> for RecursivePageTable<'a> {
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size1GiB>,
-        frame: UnusedPhysFrame<Size1GiB>,
+        frame: PhysFrame<Size1GiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>
@@ -310,10 +310,10 @@ impl<'a> Mapper<Size1GiB> for RecursivePageTable<'a> {
 
 impl<'a> Mapper<Size2MiB> for RecursivePageTable<'a> {
     #[inline]
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size2MiB>,
-        frame: UnusedPhysFrame<Size2MiB>,
+        frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
@@ -415,10 +415,10 @@ impl<'a> Mapper<Size2MiB> for RecursivePageTable<'a> {
 }
 
 impl<'a> Mapper<Size4KiB> for RecursivePageTable<'a> {
-    fn map_to<A>(
+    unsafe fn map_to<A>(
         &mut self,
         page: Page<Size4KiB>,
-        frame: UnusedPhysFrame<Size4KiB>,
+        frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         allocator: &mut A,
     ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>