Enum sunrise_kernel::paging::process_memory::DynamicHierarchy

enum DynamicHierarchy<'a> {
    Active(ActiveHierarchy),
    Inactive(&'a mut InactiveHierarchy),
}

Page tables selector.

A process always stores its table_hierarchy as an inactive hierarchy. When it wants to modify its page tables, it will first call get_hierarchy, which will detect if the hierarchy is already the currently active one, and return a DynamicHierarchy.

This returned DynamicHierarchy is just a wrapper which will dispatch all its calls to the right hierarchy, either the already active one, shortcutting the method calls by not having to map temporary directories and page tables, or going the long way and actually use the inactive one.

Variants

Active(ActiveHierarchy)

The process's hierarchy is already the currently active one.

Inactive(&'a mut InactiveHierarchy)

The process's hierarchy an inactive one.

Trait Implementations

impl<'b> TableHierarchy for DynamicHierarchy<'b>

type TopLevelTableType = ()

The type of the top level table.

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

Gets a reference to the top level table, either through recursive mapping, or by temporarily mapping it in the currently active page tables.

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.