remove recursive page table

Author: wangrunji0408

src/addr/gpax4.rs

@@ -4,6 +4,7 @@ use core::convert::TryInto;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct GPAddrSv32X4(u64);
+
 impl Address for GPAddrSv32X4 {
     fn new(addr: usize) -> Self {
         Self::new_u64(addr as u64)
@@ -21,6 +22,7 @@ impl Address for GPAddrSv32X4 {
         GPAddrSv32X4((self.0 >> 12) << 12)
     }
 }
+
 impl VirtualAddress for GPAddrSv32X4 {
     unsafe fn as_mut<'a, 'b, T>(&'a self) -> &'b mut T {
         &mut *(self.0 as *mut T)
@@ -31,7 +33,6 @@ impl AddressL2 for GPAddrSv32X4 {
     fn p2_index(&self) -> usize {
         self.0.get_bits(22..34) as usize
     }
-
     fn p1_index(&self) -> usize {
         self.0.get_bits(12..22) as usize
     }
@@ -61,6 +62,7 @@ impl AddressX64 for GPAddrSv32X4 {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct GPAddrSv39X4(u64);
+
 impl Address for GPAddrSv39X4 {
     fn new(addr: usize) -> Self {
         GPAddrSv39X4(addr.try_into().unwrap())
@@ -78,6 +80,7 @@ impl Address for GPAddrSv39X4 {
         GPAddrSv39X4((self.0 >> 12) << 12)
     }
 }
+
 impl VirtualAddress for GPAddrSv39X4 {
     unsafe fn as_mut<'a, 'b, T>(&'a self) -> &'b mut T {
         &mut *(self.0 as *mut T)
@@ -91,7 +94,6 @@ impl AddressL3 for GPAddrSv39X4 {
     fn p2_index(&self) -> usize {
         self.0.get_bits(21..30) as usize
     }
-
     fn p1_index(&self) -> usize {
         self.0.get_bits(12..21) as usize
     }
@@ -130,6 +132,7 @@ impl AddressX64 for GPAddrSv39X4 {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct GPAddrSv48X4(u64);
+
 impl Address for GPAddrSv48X4 {
     fn new(addr: usize) -> Self {
         GPAddrSv48X4(addr.try_into().unwrap())
@@ -147,6 +150,7 @@ impl Address for GPAddrSv48X4 {
         GPAddrSv48X4((self.0 >> 12) << 12)
     }
 }
+
 impl VirtualAddress for GPAddrSv48X4 {
     unsafe fn as_mut<'a, 'b, T>(&'a self) -> &'b mut T {
         &mut *(self.0 as *mut T)
@@ -157,14 +161,12 @@ impl AddressL4 for GPAddrSv48X4 {
     fn p4_index(&self) -> usize {
         self.0.get_bits(39..50) as usize
     }
-
     fn p3_index(&self) -> usize {
         self.0.get_bits(30..39) as usize
     }
     fn p2_index(&self) -> usize {
         self.0.get_bits(21..30) as usize
     }
-
     fn p1_index(&self) -> usize {
         self.0.get_bits(12..21) as usize
     }

src/paging/mapper.rs

@@ -0,0 +1,136 @@
+use super::frame_alloc::*;
+use super::page_table::*;
+use addr::*;
+
+pub trait Mapper {
+    type P: PhysicalAddress;
+    type V: VirtualAddress;
+    type MapperFlush: MapperFlushable;
+    type Entry: PTE;
+
+    /// Creates a new mapping in the page table.
+    ///
+    /// 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(
+        &mut self,
+        page: PageWith<Self::V>,
+        frame: FrameWith<Self::P>,
+        flags: PageTableFlags,
+        allocator: &mut impl FrameAllocatorFor<<Self as Mapper>::P>,
+    ) -> Result<Self::MapperFlush, MapToError>;
+
+    /// Removes a mapping from the page table and returns the frame that used to be mapped.
+    ///
+    /// Note that no page tables or pages are deallocated.
+    fn unmap(
+        &mut self,
+        page: PageWith<Self::V>,
+    ) -> Result<(FrameWith<Self::P>, Self::MapperFlush), UnmapError<<Self as Mapper>::P>>;
+
+    /// Get the reference of the specified `page` entry
+    fn ref_entry(&mut self, page: PageWith<Self::V>) -> Result<&mut Self::Entry, FlagUpdateError>;
+
+    /// Updates the flags of an existing mapping.
+    fn update_flags(
+        &mut self,
+        page: PageWith<Self::V>,
+        flags: PageTableFlags,
+    ) -> Result<Self::MapperFlush, FlagUpdateError> {
+        self.ref_entry(page).map(|e| {
+            e.set(e.frame::<Self::P>(), flags);
+            Self::MapperFlush::new(page)
+        })
+    }
+
+    /// Return the frame that the specified page is mapped to.
+    fn translate_page(&mut self, page: PageWith<Self::V>) -> Option<FrameWith<Self::P>> {
+        match self.ref_entry(page) {
+            Ok(e) => {
+                if e.is_unused() {
+                    None
+                } else {
+                    Some(e.frame())
+                }
+            }
+            Err(_) => None,
+        }
+    }
+
+    /// Maps the given frame to the virtual page with the same address.
+    fn identity_map(
+        &mut self,
+        frame: FrameWith<Self::P>,
+        flags: PageTableFlags,
+        allocator: &mut impl FrameAllocatorFor<<Self as Mapper>::P>,
+    ) -> Result<Self::MapperFlush, MapToError> {
+        let page = PageWith::of_addr(Self::V::new(frame.start_address().as_usize()));
+        self.map_to(page, frame, flags, allocator)
+    }
+}
+
+pub trait MapperFlushable {
+    /// Create a new flush promise
+    fn new<T: VirtualAddress>(page: PageWith<T>) -> Self;
+    /// Flush the page from the TLB to ensure that the newest mapping is used.
+    fn flush(self);
+    /// Don't flush the TLB and silence the “must be used” warning.
+    fn ignore(self);
+}
+
+#[must_use = "Page Table changes must be flushed or ignored."]
+pub struct MapperFlush(usize);
+
+impl MapperFlushable for MapperFlush {
+    fn new<T: VirtualAddress>(page: PageWith<T>) -> Self {
+        MapperFlush(page.start_address().as_usize())
+    }
+    fn flush(self) {
+        unsafe {
+            crate::asm::sfence_vma(0, self.0);
+        }
+    }
+    fn ignore(self) {}
+}
+
+/// This error is returned from `map_to` and similar methods.
+#[derive(Debug)]
+pub enum MapToError {
+    /// An additional frame was needed for the mapping process, but the frame allocator
+    /// returned `None`.
+    FrameAllocationFailed,
+    /// An upper level page table entry has the `HUGE_PAGE` flag set, which means that the
+    /// given page is part of an already mapped huge page.
+    ParentEntryHugePage,
+    /// The given page is already mapped to a physical frame.
+    PageAlreadyMapped,
+}
+
+/// An error indicating that an `unmap` call failed.
+#[derive(Debug)]
+pub enum UnmapError<P: PhysicalAddress> {
+    /// An upper level page table entry has the `HUGE_PAGE` flag set, which means that the
+    /// given page is part of a huge page and can't be freed individually.
+    ParentEntryHugePage,
+    /// The given page is not mapped to a physical frame.
+    PageNotMapped,
+    /// The page table entry for the given page points to an invalid physical address.
+    InvalidFrameAddress(P),
+}
+
+/// An error indicating that an `update_flags` call failed.
+#[derive(Debug)]
+pub enum FlagUpdateError {
+    /// The given page is not mapped to a physical frame.
+    PageNotMapped,
+}
+
+pub trait MapperExt {
+    type Page;
+    type Frame;
+}
+
+impl<T: Mapper> MapperExt for T {
+    type Page = PageWith<<T as Mapper>::V>;
+    type Frame = FrameWith<<T as Mapper>::P>;
+}

src/paging/mod.rs

@@ -1,13 +1,13 @@
 mod frame_alloc;
+mod mapper;
 mod multi_level;
 mod multi_level_x4;
 mod page_table;
 mod page_table_x4;
-mod recursive;
 
 pub use self::frame_alloc::*;
+pub use self::mapper::*;
 pub use self::multi_level::*;
 pub use self::multi_level_x4::*;
 pub use self::page_table::*;
 pub use self::page_table_x4::*;
-pub use self::recursive::*;

src/paging/multi_level.rs

@@ -1,14 +1,14 @@
 use super::frame_alloc::*;
+use super::mapper::*;
 use super::page_table::{PageTableFlags as F, *};
-use super::recursive::*;
 use crate::addr::*;
 use core::marker::PhantomData;
-/// This struct is a two level page table with `Mapper` trait implemented.
 
+/// This struct is a two level page table with `Mapper` trait implemented.
 pub struct Rv32PageTableWith<'a, V: VirtualAddress + AddressL2, FL: MapperFlushable> {
     root_table: &'a mut PageTableX32,
     linear_offset: u64, // VA = PA + linear_offset
-    phantom: PhantomData<fn() -> (V, FL)>,
+    phantom: PhantomData<(V, FL)>,
 }
 
 impl<'a, V: VirtualAddress + AddressL2, FL: MapperFlushable> Rv32PageTableWith<'a, V, FL> {
@@ -98,7 +98,7 @@ impl<'a, V: VirtualAddress + AddressL2, FL: MapperFlushable> Mapper
 pub struct Rv39PageTableWith<'a, V: VirtualAddress + AddressL3, FL: MapperFlushable> {
     root_table: &'a mut PageTableX64,
     linear_offset: u64, // VA = PA + linear_offset
-    phantom: PhantomData<fn() -> (V, FL)>,
+    phantom: PhantomData<(V, FL)>,
 }
 
 impl<'a, V: VirtualAddress + AddressL3, FL: MapperFlushable> Rv39PageTableWith<'a, V, FL> {
@@ -211,7 +211,7 @@ impl<'a, V: VirtualAddress + AddressL3, FL: MapperFlushable> Mapper
 pub struct Rv48PageTableWith<'a, V: VirtualAddress + AddressL4, FL: MapperFlushable> {
     root_table: &'a mut PageTableX64,
     linear_offset: u64, // VA = PA + linear_offset
-    phantom: PhantomData<*const (V, FL)>,
+    phantom: PhantomData<(V, FL)>,
 }
 
 impl<'a, V: VirtualAddress + AddressL4, FL: MapperFlushable> Rv48PageTableWith<'a, V, FL> {

src/paging/multi_level_x4.rs

@@ -1,8 +1,8 @@
 use crate::addr::*;
 use crate::asm::{hfence_gvma, hfence_vvma};
+use crate::paging::mapper::MapperFlushable;
 use crate::paging::multi_level::Rv32PageTableWith;
 use crate::paging::multi_level::{Rv39PageTableWith, Rv48PageTableWith};
-use crate::paging::recursive::MapperFlushable;
 
 #[must_use = "Guest Physical Address Table changes must be flushed or ignored."]
 pub struct MapperFlushGPA(usize);
@@ -16,7 +16,6 @@ impl MapperFlushable for MapperFlushGPA {
             hfence_gvma(self.0, 0);
         }
     }
-
     fn ignore(self) {}
 }
 
@@ -32,7 +31,6 @@ impl MapperFlushable for MapperFlushGPT {
             hfence_vvma(self.0, 0);
         }
     }
-
     fn ignore(self) {}
 }
 

src/paging/page_table.rs

@@ -1,10 +1,12 @@
 use addr::*;
 use core::convert::TryInto;
 use core::fmt::{Debug, Error, Formatter};
+use core::marker::PhantomData;
 use core::ops::{Index, IndexMut};
 
 pub type Entries32 = [PageTableEntryX32; RV32_ENTRY_COUNT];
 pub type Entries64 = [PageTableEntryX64; RV64_ENTRY_COUNT];
+
 // To avoid const generic.
 pub trait PTEIterableSlice<T> {
     fn to_pte_slice<'a>(&'a self) -> &'a [T];
@@ -55,28 +57,6 @@ impl<T: PTEIterableSlice<E>, E: PTE> PageTableWith<T, E> {
             entry.set_unused();
         }
     }
-
-    /// Parameter `frame` is the actual physical frame where the root page table resides,
-    ///  it can be anywhere in the main memory.
-    /// Denote `recursive_index` by K, then virtual address of the root page table is
-    ///  (K, K+1, 0) in Sv32, and (K, K, K+1, 0) in Sv39, and (K, K, K, K+1, 0) in Sv48.
-    pub fn set_recursive<F: PhysicalAddress>(
-        &mut self,
-        recursive_index: usize,
-        frame: FrameWith<F>,
-    ) {
-        self[recursive_index].set(frame.clone(), EF::VALID);
-        self[recursive_index + 1].set(frame.clone(), EF::VALID | EF::READABLE | EF::WRITABLE);
-    }
-
-    /// Setup identity map for the page with first level page table index.
-    #[cfg(riscv32)]
-    pub fn map_identity(&mut self, p2idx: usize, flags: PageTableFlags) {
-        self.entries.pte_index_mut(p2idx).set(
-            FrameWith::of_addr(PhysAddrSv32::new_u64((p2idx as u64) << 22)),
-            flags,
-        );
-    }
 }
 
 impl<T: PTEIterableSlice<E>, E: PTE> Index<usize> for PageTableWith<T, E> {
@@ -118,6 +98,7 @@ pub trait PTE {
     fn set<T: PhysicalAddress>(&mut self, frame: FrameWith<T>, flags: PageTableFlags);
     fn flags_mut(&mut self) -> &mut PageTableFlags;
 }
+
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct PageTableEntryX32(u32);
@@ -197,7 +178,7 @@ impl PTE for PageTableEntryX64 {
         unsafe { &mut *(self as *mut _ as *mut PageTableFlags) }
     }
 }
-use core::marker::PhantomData;
+
 pub struct PageTableEntryX64Printer<'a, P: PhysicalAddress>(
     &'a PageTableEntryX64,
     PhantomData<*const P>,