Struct x86_64::structures::paging::mapper::RecursivePageTable

pub struct RecursivePageTable<'a> { /* fields omitted */ }

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.

Implementations

impl<'a> RecursivePageTable<'a>

pub fn new(table: &'a mut PageTable) -> Result<Self, 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.

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

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(&mut self) -> &mut PageTable

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

Trait Implementations

impl<'a> CleanUp for RecursivePageTable<'a>

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

Formats the value using the given formatter.

impl<'a> Mapper<Size1GiB> for RecursivePageTable<'a>

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,
    A: FrameAllocator<Size4KiB> + ?Sized,
    S: PageSize,
    Self: Mapper<S>, 

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

impl<'a> Mapper<Size2MiB> for RecursivePageTable<'a>

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,
    A: FrameAllocator<Size4KiB> + ?Sized,
    S: PageSize,
    Self: Mapper<S>, 

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

impl<'a> Mapper<Size4KiB> for RecursivePageTable<'a>

unsafe fn map_to_with_table_flags<A>(
    &mut self,
    page: Page<Size4KiB>,
    frame: PhysFrame<Size4KiB>,
    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<Size4KiB>
) -> Result<(PhysFrame<Size4KiB>, 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<Size4KiB>,
    flags: PageTableFlags
) -> Result<MapperFlush<Size4KiB>, FlagUpdateError>

Updates the flags of an existing mapping.

unsafe fn set_flags_p4_entry(
    &mut self,
    page: Page<Size4KiB>,
    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<Size4KiB>,
    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<Size4KiB>,
    flags: PageTableFlags
) -> Result<MapperFlushAll, FlagUpdateError>

Set the flags of an existing page table level 2 entry

fn translate_page(
    &self,
    page: Page<Size4KiB>
) -> Result<PhysFrame<Size4KiB>, 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,
    A: FrameAllocator<Size4KiB> + ?Sized,
    S: PageSize,
    Self: Mapper<S>, 

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

impl<'a> Translate for RecursivePageTable<'a>

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.