Struct MemoryMapping 

pub struct MemoryMapping { /* private fields */ }

Common parts of UnalignedMemoryMapping and AlignedMemoryMapping

Implementations

impl MemoryMapping

pub unsafe fn new_with_access_violation_handler( regions: Vec<MemoryRegion>, config: &Config, sbpf_version: SBPFVersion, access_violation_handler: Box<dyn Fn(&mut MemoryRegion, u64, AccessType, u64, u64)>, ) -> Result<MemoryMapping, EbpfError>

Creates a new memory mapping.

Uses aligned or unaligned memory mapping depending on the value of config.aligned_memory_mapping=true.

Safety

In addition to the requirements of MemoryMapping::new_uninitialized, the provided access_violation_handler must return with its MemoryRegion unmodified, or initialized to another equally correct MemoryRegion as described in the safety invariants for new_uninitialized.

pub unsafe fn new_uninitialized( regions: Vec<MemoryRegion>, config: &Config, sbpf_version: SBPFVersion, access_violation_handler: Box<dyn Fn(&mut MemoryRegion, u64, AccessType, u64, u64)>, ) -> MemoryMapping

Creates an unitialized memory mapping

Safety

The memory pointed to by the MemoryRegions must point to a valid object live for the duration of this MemoryMapping.

For MemoryRegions marked writable, the memory pointed to by the memory region must accept arbitrary bytes being overwritten without it resulting in unsoundness (due to e.g. broken internal type invariants.)

pub unsafe fn new( regions: Vec<MemoryRegion>, config: &Config, sbpf_version: SBPFVersion, ) -> Result<MemoryMapping, EbpfError>

Creates a new memory mapping for tests and benches.

access_violation_handler defaults to a function which always returns an error.

Safety

Refer to MemoryMapping::new_uninitialized.

pub fn map( &self, access_type: AccessType, vm_addr: u64, len: u64, ) -> StableResult<u64, EbpfError>

Map virtual memory to host memory.

pub fn map_with_access_violation_handler( &mut self, access_type: AccessType, vm_addr: u64, len: u64, ) -> StableResult<u64, EbpfError>

Map virtual memory to host memory and potentially call the AccessViolationHandler.

This requires the MemoryMapping to be mutable and can cause previously translated addresses to become invalid.

pub fn load<T>(&mut self, vm_addr: u64) -> StableResult<u64, EbpfError>

where T: Pod + Into<u64>,

Loads size_of::<T>() bytes from the given address.

pub fn store<T>( &mut self, value: T, vm_addr: u64, ) -> StableResult<u64, EbpfError>

where T: Pod,

Store value at the given address.

pub fn find_region(&self, vm_addr: u64) -> Option<(usize, &MemoryRegion)>

Returns the MemoryRegion which may contain the given address.

pub fn get_regions(&self) -> &[MemoryRegion]

Returns the MemoryRegions in this mapping.

pub fn get_regions_mut(&mut self) -> &mut [MemoryRegion]

Returns the MemoryRegions as mutable.

Modifying the regions might break the initialization constraints, so this function uninitializes the mapping. The memory mappings must be initialized again with Self::initialize before further use.

pub unsafe fn replace_region( &mut self, index: usize, region: MemoryRegion, ) -> Result<(), EbpfError>

Replaces the MemoryRegion at the given index

Safety

Refer to MemoryMapping::new_uninitialized.

pub fn initialize(&mut self) -> Result<(), EbpfError>

Initialize the MemoryMapping

Trait Implementations

impl Debug for MemoryMapping

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

Formats the value using the given formatter.