Struct sunrise_kernel::paging::InactiveHierarchy

pub struct InactiveHierarchy {
    directory_physical_address: PhysicalAddress,
}

A currently inactive hierarchy of directory and tables.

Can be read and modified by temporarily mapping its InactivePageDirectory.

Fields

directory_physical_address: PhysicalAddress

The address we must put in cr3 to switch to these pages.

Trait Implementations

impl Debug for InactiveHierarchy

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Drop for InactiveHierarchy

fn drop(&mut self)

When a process dies, its InactiveHierarchy is dropped. The pages themselves have already been freed by the bookkeeping, we just have to free the tables and the directory of this hierarchy.

However we must free only the tables that map UserLand memory, as the ones mapping KernelLand are shared with other processes and are still in use.

impl InactiveHierarchyTrait for InactiveHierarchy

fn new() -> Self

Creates a hierarchy. Allocates at least a top level directory, makes all its entries unmapped, and makes its last entry recursive.

fn switch_to(&mut self)

Switches to this hierarchy.

fn copy_active_kernel_space(&mut self)

Performs a shallow copy of the top level-directory section that maps KernelLand tables.

fn is_currently_active(&self) -> bool

Checks if this inactive hierarchy is actually the currently active one.

unsafe fn from_currently_active() -> Self

Returns the currently active hierarchy as an inactive hierarchy.

impl TableHierarchy for InactiveHierarchy

type TopLevelTableType = InactivePageDirectory

The type of the top level table.

fn get_top_level_table(
    &mut self
) -> SmartHierarchicalTable<InactivePageDirectory>

Gets the InactivePageDirectory by temporarily mapping it.

fn map_to_from_iterator<I>(
    &mut self,
    frames_iterator: I,
    start_address: VirtualAddress,
    flags: MappingAccessRights
) where
    I: Iterator<Item = PhysicalAddress>, 

Creates a mapping in the page tables with the given flags.

fn guard(&mut self, address: VirtualAddress, length: usize)

Creates a span of guard pages

fn unmap<C>(&mut self, address: VirtualAddress, length: usize, callback: C) where
    C: FnMut(PhysicalAddress), 

Unmaps a range of virtual address. On every frames mapped by a level 0 table, the closure passed as parameter will be called after having deleted the entry. If unmap encounters a guard page, it is unmapped, and the closure is not called. If unmap encounters a HUGE guard page, it decides if it must split it and might create a child table which is only partly guarded. If unmap encounters a non-mapped entry, it panics, as this is probably a bug.

fn for_every_entry<C>(
    &mut self,
    address: VirtualAddress,
    length: usize,
    callback: C
) where
    C: FnMut(PageState<PhysicalAddress>, usize), 

Iters in the page tables, applying closure on every mapping. On every entry, the closure will be called with its state and the length it maps.

fn find_available_virtual_space_aligned(
    &mut self,
    length: usize,
    start_addr: VirtualAddress,
    end_addr: VirtualAddress,
    alignment: usize
) -> Option<VirtualAddress>

Finds a virtual space hole that is at least length long, between start_addr and end_addr.