Struct VirtualDma 

pub struct VirtualDma<T, V, D> { /* private fields */ }

The VirtualDma struct provides a default implementation to access virtual memory from user provided PhysicalMemory and VirtualTranslate2 objects.

This struct implements MemoryView and allows the user to access the virtual memory of a process.

Implementations

impl<T, D> VirtualDma<T, DirectTranslate, D>

where T: PhysicalMemory, D: VirtualTranslate3,

pub fn new( phys_mem: T, arch: impl Into<&'static dyn Architecture>, translator: D, ) -> VirtualDma<T, DirectTranslate, D>

Constructs a VirtualDma object from user supplied architectures and DTB. It creates a default VirtualTranslate2 object using the DirectTranslate struct.

If you want to use a cache for translating virtual to physical memory consider using the VirtualDma::with_vat() function and supply your own VirtualTranslate2 object.

Examples

Constructing a VirtualDma object with a given dtb and using it to read:

use memflow::types::Address;
use memflow::architecture::x86::x64;
use memflow::mem::{PhysicalMemory, VirtualTranslate2, MemoryView, VirtualDma};
use memflow::cglue::Fwd;

fn read(phys_mem: Fwd<&mut impl PhysicalMemory>, vat: &mut impl VirtualTranslate2, dtb: Address, read_addr: Address) {
    let arch = x64::ARCH;
    let translator = x64::new_translator(dtb);

    let mut virt_mem = VirtualDma::new(phys_mem, arch, translator);

    let mut addr = 0u64;
    virt_mem.read_into(read_addr, &mut addr).unwrap();
    println!("addr: {:x}", addr);
}

impl<T, V, D> VirtualDma<T, V, D>

where T: PhysicalMemory, V: VirtualTranslate2, D: VirtualTranslate3,

pub fn with_vat( phys_mem: T, arch: impl Into<&'static dyn Architecture>, translator: D, vat: V, ) -> VirtualDma<T, V, D>

This function constructs a VirtualDma instance with a user supplied VirtualTranslate2 object. It can be used when working with cached virtual to physical translations such as a Tlb.

Examples

Constructing a VirtualDma object with VAT and using it to read:

use memflow::types::Address;
use memflow::architecture::x86::x64;
use memflow::mem::{PhysicalMemory, VirtualTranslate2, MemoryView, VirtualDma};
use memflow::cglue::Fwd;

fn read(phys_mem: Fwd<&mut impl PhysicalMemory>, vat: impl VirtualTranslate2, dtb: Address, read_addr: Address) {
    let arch = x64::ARCH;
    let translator = x64::new_translator(dtb);

    let mut virt_mem = VirtualDma::with_vat(phys_mem, arch, translator, vat);

    let mut addr = 0u64;
    virt_mem.read_into(read_addr, &mut addr).unwrap();
    println!("addr: {:x}", addr);
}

pub fn sys_arch(&self) -> &'static dyn Architecture

Returns the architecture of the system. The system architecture is used for virtual to physical translations.

pub fn proc_arch(&self) -> &'static dyn Architecture

Returns the architecture of the process for this context. The process architecture is mainly used to determine pointer sizes.

pub fn set_proc_arch( &mut self, new_arch: &'static dyn Architecture, ) -> &'static dyn Architecture

Replaces current process architecture with a new one.

pub fn translator(&self) -> &D

Returns the Directory Table Base of this process..

pub fn set_translator(&mut self, new_translator: D) -> D

Replace current translator with a new one.

pub fn read_addr( &mut self, addr: Address, ) -> Result<Address, PartialError<Address>>

A wrapper around read_addr64 and read_addr32 that will use the pointer size of this context’s process. TODO: do this in virt mem

pub fn into_inner(self) -> (T, V)

Consumes this VirtualDma object, returning the underlying memory and vat objects

pub fn mem_vat_pair(&mut self) -> (&mut T, &mut V)

pub fn phys_mem(&mut self) -> &mut T

pub fn phys_mem_ref(&self) -> &T

pub fn vat(&mut self) -> &mut V

Trait Implementations

impl<T, V, D> Clone for VirtualDma<T, V, D>

where T: Clone, V: Clone, D: Clone,

fn clone(&self) -> VirtualDma<T, V, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, V, D> MemoryView for VirtualDma<T, V, D>

where T: PhysicalMemory, V: VirtualTranslate2, D: VirtualTranslate3,

fn read_raw_iter<'a>( &mut self, _: MemOps<'_, '_, '_, CTup3<Address, Address, CSliceMut<'_, u8>>, CTup2<Address, CSliceMut<'_, u8>>>, ) -> Result<(), Error>

fn write_raw_iter( &mut self, _: MemOps<'_, '_, '_, CTup3<Address, Address, CSliceRef<'_, u8>>, CTup2<Address, CSliceRef<'_, u8>>>, ) -> Result<(), Error>

fn metadata(&self) -> MemoryViewMetadata

fn read_iter<'a, 'b>( &mut self, inp: impl Iterator<Item = CTup2<Address, CSliceMut<'a, u8>>>, out: Option<&mut OpaqueCallback<'b, CTup2<Address, CSliceMut<'a, u8>>>>, out_fail: Option<&mut OpaqueCallback<'b, CTup2<Address, CSliceMut<'a, u8>>>>, ) -> Result<(), Error>

Read arbitrary amount of data.

fn read_raw_list( &mut self, data: &mut [CTup2<Address, CSliceMut<'_, u8>>], ) -> Result<(), PartialError<()>>

fn read_raw_into( &mut self, addr: Address, out: &mut [u8], ) -> Result<(), PartialError<()>>

fn read_raw( &mut self, addr: Address, len: usize, ) -> Result<Vec<u8>, PartialError<Vec<u8>>>

fn read_into<T>( &mut self, addr: Address, out: &mut T, ) -> Result<(), PartialError<()>>

where T: Pod + ?Sized, Self: Sized,

fn read<T>(&mut self, addr: Address) -> Result<T, PartialError<T>>

where T: Pod, Self: Sized,

fn read_addr32( &mut self, addr: Address, ) -> Result<Address, PartialError<Address>>

where Self: Sized,

fn read_addr64( &mut self, addr: Address, ) -> Result<Address, PartialError<Address>>

where Self: Sized,

fn read_addr_arch( &mut self, arch: &'static dyn Architecture, addr: Address, ) -> Result<Address, PartialError<Address>>

where Self: Sized,

fn read_ptr_into<U, T>( &mut self, ptr: Pointer<U, T>, out: &mut T, ) -> Result<(), PartialError<()>>

where U: PrimitiveAddress, T: Pod + ?Sized, Self: Sized,

fn read_ptr<U, T>(&mut self, ptr: Pointer<U, T>) -> Result<T, PartialError<T>>

where U: PrimitiveAddress, T: Pod, Self: Sized,

fn write_iter<'a, 'b>( &mut self, inp: impl Iterator<Item = CTup2<Address, CSliceRef<'a, u8>>>, out: Option<&mut OpaqueCallback<'b, CTup2<Address, CSliceRef<'a, u8>>>>, out_fail: Option<&mut OpaqueCallback<'b, CTup2<Address, CSliceRef<'a, u8>>>>, ) -> Result<(), Error>

Write arbitrary amount of data.

fn write_raw_list( &mut self, data: &[CTup2<Address, CSliceRef<'_, u8>>], ) -> Result<(), PartialError<()>>

fn write_raw( &mut self, addr: Address, data: &[u8], ) -> Result<(), PartialError<()>>

fn write<T>(&mut self, addr: Address, data: &T) -> Result<(), PartialError<()>>

where T: Pod + ?Sized, Self: Sized,

fn write_ptr<U, T>( &mut self, ptr: Pointer<U, T>, data: &T, ) -> Result<(), PartialError<()>>

where U: PrimitiveAddress, T: Pod + ?Sized, Self: Sized,

fn read_char_array( &mut self, addr: Address, len: usize, ) -> Result<String, PartialError<String>>

👎Deprecated: please use read_utf8 or read_utf8_lossy instead

Reads a fixed length string from the target.

fn read_char_string_n( &mut self, addr: Address, n: usize, ) -> Result<String, PartialError<String>>

👎Deprecated: please use read_utf8 or read_utf8_lossy instead

Reads a variable length string with a length of up to specified amount from the target.

fn read_char_string( &mut self, addr: Address, ) -> Result<String, PartialError<String>>

👎Deprecated: please use read_utf8 or read_utf8_lossy instead

Reads a variable length string with up to 4kb length from the target.

fn read_utf8( &mut self, addr: Address, max_length: usize, ) -> Result<String, PartialError<String>>

Reads a string at the given position with a length of up to max_length characters.

fn read_utf8_lossy( &mut self, addr: Address, max_length: usize, ) -> Result<String, PartialError<String>>

Reads a string at the given position with a length of up to max_length characters.

fn cursor(&mut self) -> MemoryCursor<Fwd<&mut Self>>

where Self: Sized,

Returns a cursor over this memory view. See MemoryCursor for more details.

fn into_cursor(self) -> MemoryCursor<Self>

where Self: Sized,

Converts this memory view into a cursor. See MemoryCursor for more details.

fn cursor_at(&mut self, address: Address) -> MemoryCursor<Fwd<&mut Self>>

where Self: Sized,

Returns a cursor over this memory view at the specified address. See MemoryCursor for more details.

fn into_cursor_at(self, address: Address) -> MemoryCursor<Self>

where Self: Sized,

Converts this memory view into a cursor at the specified address. See MemoryCursor for more details.

fn batcher(&mut self) -> MemoryViewBatcher<'_, Self>

where Self: Sized,

fn into_overlay_arch( self, arch: &'static dyn Architecture, ) -> ArchOverlayView<Self>

where Self: Sized,

fn overlay_arch( &mut self, arch: &'static dyn Architecture, ) -> ArchOverlayView<Fwd<&mut Self>>

where Self: Sized,

fn into_overlay_arch_parts( self, arch_bits: u8, little_endian: bool, ) -> ArchOverlayView<Self>

where Self: Sized,

fn overlay_arch_parts( &mut self, arch_bits: u8, little_endian: bool, ) -> ArchOverlayView<Fwd<&mut Self>>

where Self: Sized,

fn into_remap_view(self, mem_map: MemoryMap<(Address, u64)>) -> RemapView<Self>

where Self: Sized,

fn remap_view( &mut self, mem_map: MemoryMap<(Address, u64)>, ) -> RemapView<Fwd<&mut Self>>

where Self: Sized,

fn into_phys_mem(self) -> PhysicalMemoryOnView<Self>

where Self: Sized,

fn phys_mem(&mut self) -> PhysicalMemoryOnView<Fwd<&mut Self>>

where Self: Sized,

impl<T, V, D> VirtualTranslate for VirtualDma<T, V, D>

where T: PhysicalMemory, V: VirtualTranslate2, D: VirtualTranslate3,

fn virt_to_phys_list( &mut self, addrs: &[CTup2<Address, u64>], out: OpaqueCallback<'_, VirtualTranslation>, out_fail: OpaqueCallback<'_, VirtualTranslationFail>, )

Translate a list of address ranges into physical address space.

fn virt_to_phys_range( &mut self, start: Address, end: Address, out: OpaqueCallback<'_, VirtualTranslation>, )

Translate a single virtual address range into physical address space.

fn virt_translation_map_range( &mut self, start: Address, end: Address, out: OpaqueCallback<'_, VirtualTranslation>, )

Translate a single virtual address range into physical address space and coalesce nearby regions.

fn virt_page_map_range( &mut self, gap_size: i64, start: Address, end: Address, out: OpaqueCallback<'_, CTup3<Address, u64, PageType>>, )

Retrieves mapped virtual pages in the specified range.

fn virt_to_phys(&mut self, address: Address) -> Result<PhysicalAddress, Error>

Translate a single virtual address into a single physical address.

fn virt_page_info(&mut self, addr: Address) -> Result<Page, Error>

Retrieve page information at virtual address.

fn virt_page_map_range_vec( &mut self, gap_size: i64, start: Address, end: Address, ) -> Vec<CTup3<Address, u64, PageType>>

Retrieve a vector of physical pages within given range.

fn virt_translation_map(&mut self, out: OpaqueCallback<'_, VirtualTranslation>)

Get virtual translation map over entire address space.

fn virt_translation_map_vec(&mut self) -> Vec<VirtualTranslation>

Get virtual translation map over entire address space and return it as a vector.

fn phys_to_virt(&mut self, phys: Address) -> Option<Address>

Attempt to translate a physical address into a virtual one.

fn phys_to_virt_vec(&mut self, phys: Address) -> Vec<Address>

Retrieve all virtual address that map into a given physical address.

fn virt_page_map( &mut self, gap_size: i64, out: OpaqueCallback<'_, CTup3<Address, u64, PageType>>, )

Retrieves all mapped virtual pages.

fn virt_page_map_vec( &mut self, gap_size: i64, ) -> Vec<CTup3<Address, u64, PageType>>

Returns a Vec of all mapped virtual pages.