Struct RecursivePageTable 

pub struct RecursivePageTable<'a> {
    p4: &'a mut PageTable,
    recursive_index: PageTableIndex,
}

A recursive page table is a last level page table with an entry mapped to the table itself.

This recursive mapping allows accessing all page tables in the hierarchy:

• To access the level 4 page table, we “loop“ (i.e. follow the recursively mapped entry) four times.
• To access a level 3 page table, we “loop” three times and then use the level 4 index.
• To access a level 2 page table, we “loop” two times, then use the level 4 index, then the level 3 index.
• To access a level 1 page table, we “loop” once, then use the level 4 index, then the level 3 index, then the level 2 index.

This struct implements the Mapper trait.

The page table flags PRESENT and WRITABLE are always set for higher level page table entries, even if not specified, because the design of the recursive page table requires it.

Fields

p4: &'a mut PageTable

recursive_index: PageTableIndex

Implementations

impl<'a> RecursivePageTable<'a>

pub fn new( table: &'a mut PageTable, ) -> Result<RecursivePageTable<'a>, InvalidPageTable>

Creates a new RecursivePageTable from the passed level 4 PageTable.

The page table must be recursively mapped, that means:

• The page table must have one recursive entry, i.e. an entry that points to the table itself.
  • The reference must use that “loop”, i.e. be of the form 0o_xxx_xxx_xxx_xxx_0000 where xxx is the recursive entry.
• The page table must be active, i.e. the CR3 register must contain its physical address.

Otherwise Err(()) is returned.

Safety

Note that creating a PageTable with recursive index 511 is unsound because allocating the last byte of the address space can lead to pointer overflows and undefined behavior. For more details, see the discussions on Zulip and in the unsafe-code-guidelines repo.

pub unsafe fn new_unchecked( table: &'a mut PageTable, recursive_index: PageTableIndex, ) -> RecursivePageTable<'a>

Creates a new RecursivePageTable without performing any checks.

Safety

The given page table must be a level 4 page table that is active in the CPU (i.e. loaded in the CR3 register). The recursive_index parameter must be the index of the recursively mapped entry of that page table.

pub fn level_4_table(&self) -> &PageTable

Returns an immutable reference to the wrapped level 4 PageTable instance.

pub fn level_4_table_mut(&mut self) -> &mut PageTable

Returns a mutable reference to the wrapped level 4 PageTable instance.

Trait Implementations

impl CleanUp for RecursivePageTable<'_>

unsafe fn clean_up<D>(&mut self, frame_deallocator: &mut D)

where D: FrameDeallocator<Size4KiB>,

Remove all empty P1-P3 tables

unsafe fn clean_up_addr_range<D>( &mut self, range: PageRangeInclusive, frame_deallocator: &mut D, )

where D: FrameDeallocator<Size4KiB>,

Remove all empty P1-P3 tables in a certain range

impl<'a> Debug for RecursivePageTable<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Mapper<Size1GiB> for RecursivePageTable<'_>

unsafe fn map_to_with_table_flags<A>( &mut self, page: Page<Size1GiB>, frame: PhysFrame<Size1GiB>, flags: PageTableFlags, parent_table_flags: PageTableFlags, allocator: &mut A, ) -> Result<MapperFlush<Size1GiB>, MapToError<Size1GiB>>

where A: FrameAllocator<Size4KiB> + ?Sized,

Creates a new mapping in the page table.

fn unmap( &mut self, page: Page<Size1GiB>, ) -> Result<(PhysFrame<Size1GiB>, MapperFlush<Size1GiB>), UnmapError>

Removes a mapping from the page table and returns the frame that used to be mapped.

unsafe fn update_flags( &mut self, page: Page<Size1GiB>, flags: PageTableFlags, ) -> Result<MapperFlush<Size1GiB>, FlagUpdateError>

Updates the flags of an existing mapping.

unsafe fn set_flags_p4_entry( &mut self, page: Page<Size1GiB>, flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page level 4 table entry

unsafe fn set_flags_p3_entry( &mut self, _page: Page<Size1GiB>, _flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page table level 3 entry

unsafe fn set_flags_p2_entry( &mut self, _page: Page<Size1GiB>, _flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page table level 2 entry

fn translate_page( &self, page: Page<Size1GiB>, ) -> Result<PhysFrame<Size1GiB>, TranslateError>

Return the frame that the specified page is mapped to.

unsafe fn map_to<A>( &mut self, page: Page<S>, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError<S>>

where Self: Sized, A: FrameAllocator<Size4KiB> + ?Sized,

Creates a new mapping in the page table.

unsafe fn identity_map<A>( &mut self, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError<S>>

where Self: Sized + Mapper<S>, A: FrameAllocator<Size4KiB> + ?Sized, S: PageSize,

Maps the given frame to the virtual page with the same address.

impl Mapper<Size2MiB> for RecursivePageTable<'_>

unsafe fn map_to_with_table_flags<A>( &mut self, page: Page<Size2MiB>, frame: PhysFrame<Size2MiB>, flags: PageTableFlags, parent_table_flags: PageTableFlags, allocator: &mut A, ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>

where A: FrameAllocator<Size4KiB> + ?Sized,

Creates a new mapping in the page table.

fn unmap( &mut self, page: Page<Size2MiB>, ) -> Result<(PhysFrame<Size2MiB>, MapperFlush<Size2MiB>), UnmapError>

Removes a mapping from the page table and returns the frame that used to be mapped.

unsafe fn update_flags( &mut self, page: Page<Size2MiB>, flags: PageTableFlags, ) -> Result<MapperFlush<Size2MiB>, FlagUpdateError>

Updates the flags of an existing mapping.

unsafe fn set_flags_p4_entry( &mut self, page: Page<Size2MiB>, flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page level 4 table entry

unsafe fn set_flags_p3_entry( &mut self, page: Page<Size2MiB>, flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page table level 3 entry

unsafe fn set_flags_p2_entry( &mut self, _page: Page<Size2MiB>, _flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page table level 2 entry

fn translate_page( &self, page: Page<Size2MiB>, ) -> Result<PhysFrame<Size2MiB>, TranslateError>

Return the frame that the specified page is mapped to.

unsafe fn map_to<A>( &mut self, page: Page<S>, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError<S>>

where Self: Sized, A: FrameAllocator<Size4KiB> + ?Sized,

Creates a new mapping in the page table.

unsafe fn identity_map<A>( &mut self, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError<S>>

where Self: Sized + Mapper<S>, A: FrameAllocator<Size4KiB> + ?Sized, S: PageSize,

Maps the given frame to the virtual page with the same address.

impl Mapper<Size4KiB> for RecursivePageTable<'_>

unsafe fn map_to_with_table_flags<A>( &mut self, page: Page, frame: PhysFrame, flags: PageTableFlags, parent_table_flags: PageTableFlags, allocator: &mut A, ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>

where A: FrameAllocator<Size4KiB> + ?Sized,

Creates a new mapping in the page table.

fn unmap( &mut self, page: Page, ) -> Result<(PhysFrame, MapperFlush<Size4KiB>), UnmapError>

Removes a mapping from the page table and returns the frame that used to be mapped.

unsafe fn update_flags( &mut self, page: Page, flags: PageTableFlags, ) -> Result<MapperFlush<Size4KiB>, FlagUpdateError>

Updates the flags of an existing mapping.

unsafe fn set_flags_p4_entry( &mut self, page: Page, flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page level 4 table entry

unsafe fn set_flags_p3_entry( &mut self, page: Page, flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page table level 3 entry

unsafe fn set_flags_p2_entry( &mut self, page: Page, flags: PageTableFlags, ) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page table level 2 entry

fn translate_page(&self, page: Page) -> Result<PhysFrame, TranslateError>

Return the frame that the specified page is mapped to.

unsafe fn map_to<A>( &mut self, page: Page<S>, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError<S>>

where Self: Sized, A: FrameAllocator<Size4KiB> + ?Sized,

Creates a new mapping in the page table.

unsafe fn identity_map<A>( &mut self, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError<S>>

where Self: Sized + Mapper<S>, A: FrameAllocator<Size4KiB> + ?Sized, S: PageSize,

Maps the given frame to the virtual page with the same address.

impl Translate for RecursivePageTable<'_>

fn translate(&self, addr: VirtAddr) -> TranslateResult

Return the frame that the given virtual address is mapped to and the offset within that frame.

fn translate_addr(&self, addr: VirtAddr) -> Option<PhysAddr>

Translates the given virtual address to the physical address that it maps to.