Struct page_table::PageTable64

pub struct PageTable64<M: PagingMetaData, PTE: GenericPTE, IF: PagingIf> { /* private fields */ }

A generic page table struct for 64-bit platform.

It also tracks all intermediate level tables. They will be deallocated When the PageTable64 itself is dropped.

Implementations

impl<M: PagingMetaData, PTE: GenericPTE, IF: PagingIf> PageTable64<M, PTE, IF>

pub fn try_new() -> PagingResult<Self>

Creates a new page table instance or returns the error.

It will allocate a new page for the root page table.

pub const fn root_paddr(&self) -> PhysAddr

Returns the physical address of the root page table.

pub fn map( &mut self, vaddr: VirtAddr, target: PhysAddr, page_size: PageSize, flags: MappingFlags ) -> PagingResult

Maps a virtual page to a physical frame with the given page_size and mapping flags.

The virtual page starts with vaddr, amd the physical frame starts with target. If the addresses is not aligned to the page size, they will be aligned down automatically.

Returns Err(PagingError::AlreadyMapped) if the mapping is already present.

pub fn map_overwrite( &mut self, vaddr: VirtAddr, target: PhysAddr, page_size: PageSize, flags: MappingFlags ) -> PagingResult

Same as PageTable64::map(). This function will error if entry doesn’t exist. Should be used to edit PTE in page fault handler.

pub fn unmap(&mut self, vaddr: VirtAddr) -> PagingResult<(PhysAddr, PageSize)>

Unmaps the mapping starts with vaddr.

Returns Err(PagingError::NotMapped) if the mapping is not present.

pub fn map_fault( &mut self, vaddr: VirtAddr, page_size: PageSize, flags: MappingFlags ) -> PagingResult

Maps a fault page starts with vaddr.

pub fn query( &self, vaddr: VirtAddr ) -> PagingResult<(PhysAddr, MappingFlags, PageSize)>

Query the result of the mapping starts with vaddr.

Returns the physical address of the target frame, mapping flags, and the page size.

Returns Err(PagingError::NotMapped) if the mapping is not present.

pub fn update( &mut self, vaddr: VirtAddr, paddr: Option<PhysAddr>, flags: Option<MappingFlags> ) -> PagingResult<PageSize>

Updates the target or flags of the mapping starts with vaddr. If the corresponding argument is None, it will not be updated.

Returns the page size of the mapping.

Returns Err(PagingError::NotMapped) if the mapping is not present.

pub fn map_region( &mut self, vaddr: VirtAddr, paddr: PhysAddr, size: usize, flags: MappingFlags, allow_huge: bool ) -> PagingResult

Map a contiguous virtual memory region to a contiguous physical memory region with the given mapping flags.

The virtual and physical memory regions start with vaddr and paddr respectively. The region size is size. The addresses and size must be aligned to 4K, otherwise it will return Err(PagingError::NotAligned).

When allow_huge is true, it will try to map the region with huge pages if possible. Otherwise, it will map the region with 4K pages.

pub fn map_fault_region( &mut self, vaddr: VirtAddr, size: usize, flags: MappingFlags ) -> PagingResult

TODO: huge page

pub fn unmap_region(&mut self, vaddr: VirtAddr, size: usize) -> PagingResult

Unmap a contiguous virtual memory region.

The region must be mapped before using PageTable64::map_region, or unexpected behaviors may occur.

pub fn update_region( &mut self, vaddr: VirtAddr, size: usize, flags: MappingFlags ) -> PagingResult

Update the mapping flags of a contiguous virtual memory region. The region must be mapped before using PageTable64::map_region, or it will return an error.

pub fn walk<F>(&self, limit: usize, func: &F) -> PagingResult

where F: Fn(usize, usize, VirtAddr, &PTE),

Walk the page table recursively.

When reaching the leaf page table, call func on the current page table entry. The max number of enumerations in one table is limited by limit.

The arguments of func are:

• Current level (starts with 0): usize
• The index of the entry in the current-level table: usize
• The virtual address that is mapped to the entry: VirtAddr
• The reference of the entry: &PTE

impl<M: PagingMetaData, PTE: GenericPTE, IF: PagingIf> PageTable64<M, PTE, IF>

pub fn get_entry_mut( &self, vaddr: VirtAddr ) -> PagingResult<(&mut PTE, PageSize)>

To get the mutable reference of the page table entry of the given virtual address.

Trait Implementations

impl<M: PagingMetaData, PTE: GenericPTE, IF: PagingIf> Drop for PageTable64<M, PTE, IF>

fn drop(&mut self)

Executes the destructor for this type.