Struct memflow::mem::mem_map::MemoryMap

pub struct MemoryMap<M> { /* private fields */ }

The MemoryMapstruct provides a mechanism to map addresses from the linear address space that memflow uses internally to hardware specific memory regions.

All memory addresses will be bounds checked.

Examples

use memflow::prelude::{MemoryMap, CTup2, umem};

let mut map = MemoryMap::new();
map.push_remap(0x1000.into(), 0x1000, 0.into());      // push region from 0x1000 - 0x1FFF
map.push_remap(0x3000.into(), 0x1000, 0x2000.into()); // push region from 0x3000 - 0x3FFFF

println!("{:?}", map);

// handle unmapped memory regions
let failed = &mut |CTup2(a, b)| {
    println!("Unmapped: {} {}", a, b);
    true
};

let hw_addr = map.map(0x10ff.into(), 8 as umem, Some(failed));

Implementations

impl<M: SplitAtIndex> MemoryMap<M>

pub fn new() -> Self

Constructs a new memory map.

This function is identical to MemoryMap::default().

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> impl Iterator<Item = &MemoryMapping<M>>

Iterator over memory mappings

pub fn map<'a, T: 'a + SplitAtIndex, V: Callbackable<CTup2<Address, T>>>( &'a self, addr: Address, buf: T, out_fail: Option<&'a mut V> ) -> impl Iterator<Item = CTup3<M, Address, T>> + 'a

Maps a linear address range to a hardware address range.

Output element lengths will both match, so there is no need to do additonal clipping (for buf-to-buf copies).

Invalid regions get pushed to the out_fail parameter. This function requries self

pub fn map_base_iter<'a, T: 'a + SplitAtIndex, I: 'a + Iterator<Item = CTup3<Address, Address, T>>, V: Callbackable<CTup2<Address, T>>>( &'a self, iter: I, out_fail: Option<&'a mut V> ) -> MemoryMapIterator<'a, I, M, T, V>

Maps a address range iterator to an address range.

Output element lengths will both match, so there is no need to do additonal clipping (for buf-to-buf copies).

Invalid regions get pushed to the out_fail parameter

pub fn map_iter<'a, T: 'a + SplitAtIndex, I: 'a + Iterator<Item = CTup3<PhysicalAddress, Address, T>>, V: Callbackable<CTup2<Address, T>>>( &'a self, iter: I, out_fail: Option<&'a mut V> ) -> MemoryMapIterator<'a, impl Iterator<Item = CTup3<Address, Address, T>> + 'a, M, T, V>

Maps a address range iterator to a hardware address range.

Output element lengths will both match, so there is no need to do additonal clipping (for buf-to-buf copies).

Invalid regions get pushed to the out_fail parameter

pub fn push(&mut self, base: Address, output: M) -> &mut Self

Adds a new memory mapping to this memory map.

When adding overlapping memory regions this function will panic!

impl MemoryMap<(Address, umem)>

pub fn open<P: AsRef<Path>>(path: P) -> Result<Self>

Constructs a new memory map by parsing the mapping table from a TOML file.

The file must contain a mapping table in the following format:

[[range]]
base=0x1000
length=0x1000

[[range]]
base=0x2000
length=0x1000
real_base=0x3000

The real_base parameter is optional. If it is not set there will be no re-mapping.

pub fn max_address(&self) -> Address

Returns the highest memory address that can be read.

pub fn real_size(&self) -> umem

pub fn push_remap( &mut self, base: Address, size: umem, real_base: Address ) -> &mut Self

Adds a new memory mapping to this memory map by specifying base address and size of the mapping.

When adding overlapping memory regions this function will panic!

pub fn push_range( &mut self, base: Address, end: Address, real_base: Address ) -> &mut Self

Adds a new memory mapping to this memory map by specifying a range (base address and end addresses) of the mapping.

When adding overlapping memory regions this function will panic!

If end < base, the function will do nothing

pub unsafe fn into_bufmap_mut<'a>(self) -> MemoryMap<&'a mut [u8]>

Transform address mapping into mutable buffer mapping

It will take the output address-size pair, and create mutable slice references to them.

Safety

The address mappings must be valid for the given lifetime 'a, and should not be aliased by any other memory references for fully defined behaviour.

However, aliasing should be fine for volatile memory cases such as analyzing running VM, since there are no safety guarantees anyways.

pub unsafe fn into_bufmap<'a>(self) -> MemoryMap<&'a [u8]>

Transform address mapping buffer buffer mapping

It will take the output address-size pair, and create slice references to them.

Safety

The address mappings must be valid for the given lifetime 'a.

pub fn into_vec(self) -> Vec<PhysicalMemoryMapping>

pub fn from_vec(mem_map: Vec<PhysicalMemoryMapping>) -> Self

Trait Implementations

impl<'a> AsRef<MemoryMap<&'a [u8]>> for MmapInfo<'a>

fn as_ref(&self) -> &MemoryMap<&'a [u8]>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> AsRef<MemoryMap<&'a mut [u8]>> for MmapInfoMut<'a>

fn as_ref(&self) -> &MemoryMap<&'a mut [u8]>

Converts this type into a shared reference of the (usually inferred) input type.

impl<M> AsRef<MemoryMap<M>> for MemoryMap<M>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<M: Clone> Clone for MemoryMap<M>

fn clone(&self) -> MemoryMap<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M> Debug for MemoryMap<M>

where MemoryMapping<M>: Debug,

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

Formats the value using the given formatter.

impl<M: SplitAtIndex> Default for MemoryMap<M>

fn default() -> Self

Returns the “default value” for a type.

impl<M: SplitAtIndex> IntoIterator for MemoryMap<M>

type Item = (Address, M)

The type of the elements being iterated over.

type IntoIter = Map<IntoIter<MemoryMapping<M>>, fn(_: MemoryMapping<M>) -> <MemoryMap<M> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.