Struct MemoryKind 

#[repr(transparent)]
pub struct MemoryKind(pub u64);

Memory region type identifier.

Used by the bootloader to communicate the memory map to the kernel. The kernel uses this to decide which regions can be used for the buddy allocator, which are reserved for hardware, etc.

Example

let regions = /* from KernelArgs */;
for region in regions {
    match region.kind {
        MemoryKind::Free => {
            // Add to buddy allocator
            buddy_init_region(region.base, region.size);
        }
        MemoryKind::Reserved => {
            // Skip — hardware MMIO (framebuffer, APIC, etc.)
        }
        MemoryKind::Reclaim => {
            // Bootloader code — can be freed after init
            reclaim_region(region.base, region.size);
        }
        _ => {}
    }
}

Tuple Fields

0: u64

Implementations

impl MemoryKind

pub const Null: Self

Null/invalid region (should not appear in the memory map).

pub const Free: Self

Free usable memory — available for kernel allocation.

pub const Reclaim: Self

Bootloader-reclaimable memory — free after boot, before first use.

pub const Reserved: Self

Reserved memory — hardware MMIO, firmware, ACPI NVS, etc. Kernel must not allocate from these regions.

Trait Implementations

impl Clone for MemoryKind

fn clone(&self) -> MemoryKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MemoryKind

impl Debug for MemoryKind

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

Formats the value using the given formatter.

impl Eq for MemoryKind

impl FromBytes for MemoryKind

where u64: FromBytes,

fn read_from_bytes(source: &[u8]) -> Result<Self, SizeError<&[u8], Self>>

where Self: Sized,

Reads a copy of Self from the given source.

fn read_from_prefix( source: &[u8], ) -> Result<(Self, &[u8]), SizeError<&[u8], Self>>

where Self: Sized,

Reads a copy of Self from the prefix of the given source.

fn read_from_suffix( source: &[u8], ) -> Result<(&[u8], Self), SizeError<&[u8], Self>>

where Self: Sized,

Reads a copy of Self from the suffix of the given source.

impl FromZeros for MemoryKind

where u64: FromZeros,

fn zero(&mut self)

Overwrites self with zeros.

fn new_zeroed() -> Self

where Self: Sized,

Creates an instance of Self from zeroed bytes.

impl IntoBytes for MemoryKind

where u64: IntoBytes,

fn as_mut_bytes(&mut self) -> &mut [u8]

where Self: FromBytes,

Gets the bytes of this value mutably.

impl PartialEq for MemoryKind

fn eq(&self, other: &MemoryKind) -> 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 StructuralPartialEq for MemoryKind

impl TryFromBytes for MemoryKind

where u64: TryFromBytes,

fn try_read_from_bytes( source: &[u8], ) -> Result<Self, ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read the given source as a Self.

fn try_read_from_prefix( source: &[u8], ) -> Result<(Self, &[u8]), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the prefix of the given source.

fn try_read_from_suffix( source: &[u8], ) -> Result<(&[u8], Self), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the suffix of the given source.