Struct sunrise_bootstrap::paging::table::InactivePageDirectory

pub struct InactivePageDirectory(PageDirectory);

A temporary mapped page directory.

Implementations

impl InactivePageDirectory

fn delete_userspace(&mut self)

• Frees the userspace pages mapped by this set
• Frees the userspace tables frames

Does not free pages mapped in kernelspace and kernel space tables

fn copy_active_kernelspace(&mut self)

Copies all the entries in the directory mapping tables that fall in kernelspace from active page tables

Trait Implementations

impl Deref for InactivePageDirectory

type Target = PageDirectory

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for InactivePageDirectory

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for InactivePageDirectory

When the temporary inactive directory is drop, we unmap it

fn drop(&mut self)

Executes the destructor for this type.

impl HierarchicalTable for InactivePageDirectory

fn entries(&self) -> &[Entry; 1024]

fn entries_mut(&mut self) -> &mut [Entry; 1024]

fn zero(&mut self)

zero out the whole table

fn map_nth_entry<T: Flusher>(
    &mut self,
    entry: usize,
    frame: Frame,
    flags: I386EntryFlags
)

Creates a mapping on the nth entry of a table T is a flusher describing if we should flush the TLB or not

fn guard_nth_entry<T: Flusher>(&mut self, entry: usize)

Marks the nth entry as guard page T is a flusher describing if we should flush the TLB or not

fn flush_cache()

impl Index<usize> for InactivePageDirectory

type Output = <PageDirectory as Index<usize>>::Output

The returned type after indexing.

fn index(&self, index: usize) -> &Entry

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for InactivePageDirectory

fn index_mut(&mut self, index: usize) -> &mut Entry

Performs the mutable indexing (container[index]) operation.

impl PageDirectoryTrait for InactivePageDirectory

type PageTableType = InactivePageTable

type FlusherType = NoFlush

fn get_table(
    &mut self,
    index: usize
) -> PageState<SmartHierarchicalTable<Self::PageTableType>>

Temporary map the table

fn create_table(
    &mut self,
    index: usize
) -> SmartHierarchicalTable<Self::PageTableType>

Allocates a page table, temporarily map it, zero it and add an entry to the directory pointing to it

fn get_table_or_create(
    &mut self,
    index: usize
) -> SmartHierarchicalTable<Self::PageTableType>

Gets the page table at given index, or creates it if it does not exist

fn map_to(
    &mut self,
    page: Frame,
    address: VirtualAddress,
    flags: I386EntryFlags
)

Creates a mapping in the page tables with the given flags

fn guard(&mut self, address: VirtualAddress)

Creates a guard page

fn __unmap(&mut self, page: VirtualAddress) -> PageState<Frame>

Deletes a mapping in the page tables, returning the frame if it existed.

fn find_available_virtual_space_aligned<Land: VirtualSpaceLand>(
    &mut self,
    page_nb: usize,
    alignement: usize
) -> Option<VirtualAddress>

Finds a virtual space hole that can contain page_nb consecutive pages Alignment is the bitshift of a mask that the first page address must satisfy (ex: 24 for 0x**000000)