Struct VmMemory 

pub struct VmMemory {
    pub mmu: Mmu,
    /* private fields */
}

Memory for a VM run: an Mmu for the RAM space, flat storage elsewhere.

Fields

mmu: Mmu

Guest process memory.

Implementations

impl VmMemory

pub fn new() -> Self

pub fn take_fault(&mut self) -> Option<MemFault>

Returns and clears the fault recorded by the most recent failed access.

pub fn fault(&self) -> Option<MemFault>

The recorded fault, without clearing it.

A backend that has to turn a fault into the interpreter’s error type needs the address but must leave the fault itself for the VM, which is what turns it into a resumable exit.

pub fn is_flat(&self, space: MemorySpaceId) -> bool

Whether space is densely stored, and so directly addressable by compiled code. False for guest RAM, which needs the MMU’s checks.

pub fn flat_mut(&mut self) -> &mut FlatSpaces

The flat spaces, for a backend that addresses them directly.

Trait Implementations

impl Default for VmMemory

fn default() -> VmMemory

Returns the “default value” for a type.

impl DomainMemory for VmMemory

type V = SizedValue

fn read( &self, space: MemorySpaceId, addr: Self::V, size: usize, ) -> Result<Self::V, EmulatorErrorKind>

Reads a value from the given address. The size of the value must be less than or equal to the size of the region being read from.

fn write( &mut self, space: MemorySpaceId, addr: Self::V, size: usize, value: Self::V, ) -> Result<(), EmulatorErrorKind>

Writes a value to the given address. The size of the value must be less than or equal to the size of the region being written to.

impl EmulatorMemory for VmMemory

fn configure_spaces(&mut self, ctx: &Context<'_>)

Prepares per-space bookkeeping for ctx. Called before any access, and cheap to call repeatedly: spaces are append-only, so an implementation can skip the work when nothing has been added.

fn read_bytes( &self, space: MemorySpaceId, addr: u64, size: usize, ) -> Result<Vec<u8>, EmulatorErrorKind>

Reads size raw bytes, without the value-domain’s width handling.

fn write_bytes( &mut self, space: MemorySpaceId, addr: u64, bytes: &[u8], ) -> Result<(), EmulatorErrorKind>

Writes raw bytes, creating the space if it does not exist yet.