Struct MappedPages 

pub struct MappedPages {
    start_vaddr: VirtAddr,
    size: usize,
    owned: bool,
    _marker: PhantomData<*mut ()>,
}

A safely mapped memory region

MappedPages represents a contiguous virtual memory mapping to physical frames. The mapping is automatically unmapped when the MappedPages is dropped.

This is inspired by Theseus’s MappedPages abstraction.

Fields

start_vaddr: VirtAddr

Starting virtual address

size: usize

Size in bytes

owned: bool

Whether this mapping owns the underlying frames

_marker: PhantomData<*mut ()>

Marker to prevent Send/Sync (mapping is CPU-local)

Implementations

impl MappedPages

pub unsafe fn new(start_vaddr: VirtAddr, size: usize, owned: bool) -> Self

Creates a new MappedPages from an existing mapping

Safety

• The virtual address range must be a valid mapping
• The caller must ensure the mapping remains valid for the lifetime
• The size must match the actual mapping size

pub fn start_address(&self) -> VirtAddr

Returns the starting virtual address

pub fn size(&self) -> usize

Returns the size in bytes

pub fn end_address(&self) -> VirtAddr

Returns the ending virtual address (exclusive)

pub fn range(&self) -> Range<VirtAddr>

Returns the virtual address range

pub fn as_ptr(&self) -> *const u8

Returns a pointer to the start of the mapping

pub fn as_mut_ptr(&mut self) -> *mut u8

Returns a mutable pointer to the start of the mapping

pub unsafe fn read<T>(&self, offset: usize) -> Result<T, MapError>

Reads a value from the mapped memory at the given offset

Safety

• The offset + size_of::() must be within the mapping
• The memory must be properly initialized for type T
• Proper alignment must be ensured

pub unsafe fn write<T>( &mut self, offset: usize, value: T, ) -> Result<(), MapError>

Writes a value to the mapped memory at the given offset

Safety

• The offset + size_of::() must be within the mapping
• The memory must be writable (not read-only)
• Proper alignment must be ensured

pub unsafe fn as_slice(&self, len: usize) -> Result<&[u8], MapError>

Returns a slice reference to the mapped memory

Safety

• The mapping must contain initialized data
• No other mutable references to this memory can exist

pub unsafe fn as_mut_slice(&mut self, len: usize) -> Result<&mut [u8], MapError>

Returns a mutable slice reference to the mapped memory

Safety

• The mapping must be writable
• No other references to this memory can exist

pub fn into_allocated_pages(self) -> Result<AllocatedPages, MapError>

Converts this MappedPages into an AllocatedPages, consuming the mapping

This transfers ownership of the underlying frames.

Trait Implementations

impl Debug for MappedPages

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

Performs the fmt operation.

impl Drop for MappedPages

fn drop(&mut self)

Performs the drop operation.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for MappedPages