Enum MemoryType

#[repr(C)]
pub enum MemoryType {
    Conventional = 0,
    AcpiReclaimable = 1,
    FdtReclaimable = 2,
    LoadedImage = 3,
    KernelPageTables = 4,
    KernelHeap = 5,
    Loader = 6,
    BootInfo = 7,
}

Variants

Conventional = 0

Memory that can be used freely by the kernel.

AcpiReclaimable = 1

Memory that contains ACPI tables. After the OS has finished with them, this may be treated as conventional memory.

FdtReclaimable = 2

Memory that contains the Flattened Device Tree (FDT). After the OS has finished with the device tree, this memory can be treated as conventional.

LoadedImage = 3

Memory occupied by images that the loader has been asked to load from disk. If the kernel can determine that an image is no longer needed, it may use this memory.

KernelPageTables = 4

Memory that is occupied by page tables created by the loader for the kernel. If the kernel can determine that it no longer needs part of this mapped, it may use this memory.

KernelHeap = 5

Memory that has been mapped for the kernel heap.

Loader = 6

Memory that the loader maps into the kernel address space. It may be reclaimed by the kernel immediately, and the kernel should also unmap it from its address space. Seed will only produce these entries if the implementation needs to keep itself mapped - otherwise this memory may be marked Conventional.

BootInfo = 7

Memory that is occupied by the boot info constructed by the loader for the kernel. Contains the BootInfo structure, and all the structures that are referenced by it. After the kernel has finished with this data, it may use this memory.

Trait Implementations

impl Clone for MemoryType

fn clone(&self) -> MemoryType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MemoryType

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

Formats the value using the given formatter.

impl Default for MemoryType

fn default() -> MemoryType

Returns the “default value” for a type.

impl PartialEq for MemoryType

fn eq(&self, other: &MemoryType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for MemoryType

impl Eq for MemoryType

impl StructuralPartialEq for MemoryType