Trait memflow::mem::virt_translate::VirtualTranslate2

source · [−]
pub trait VirtualTranslate2 where
    Self: Send, {
    fn virt_to_phys_iter<T, B, D, VI>(
        &mut self, 
        phys_mem: &mut T, 
        translator: &D, 
        addrs: VI, 
        out: &mut VtopOutputCallback<'_, B>, 
        out_fail: &mut VtopFailureCallback<'_, B>
    )
    where
        T: PhysicalMemory + ?Sized,
        B: SplitAtIndex,
        D: VirtualTranslate3,
        VI: Iterator<Item = CTup3<Address, Address, B>>;

    fn virt_to_phys<T: PhysicalMemory + ?Sized, D: VirtualTranslate3>(
        &mut self, 
        phys_mem: &mut T, 
        translator: &D, 
        vaddr: Address
    ) -> Result<PhysicalAddress> { ... }
}

Required methods

Translate a list of virtual addresses

This function will do a virtual to physical memory translation for the VirtualTranslate3 over multiple elements.

In most cases, you will want to use the VirtualDma, but this trait is provided if needed to implement some more advanced filtering.

Examples
use memflow::mem::{VirtualTranslate2, DirectTranslate};
use memflow::types::size;
use memflow::architecture::x86::x64;
use memflow::cglue::{FromExtend, CTup3};

use std::convert::TryInto;

let arch = x64::ARCH;

let mut buffer = vec![0; VIRT_MEM_SIZE * CHUNK_SIZE / arch.page_size()];
let buffer_length = buffer.len();

// In this example, 8 megabytes starting from `virtual_base` are mapped in.
// We translate 2 bytes chunks over the page boundaries. These bytes will be
// split off into 2 separate translated chunks.
let addresses = buffer
    .chunks_mut(CHUNK_SIZE)
    .enumerate()
    .map(|(i, buf)| CTup3(virtual_base + ((i + 1) * size::kb(4) - 1), Address::NULL, buf));

let mut translated_data = vec![];
let mut failed_translations = &mut |_| true;

let mut direct_translate = DirectTranslate::new();

direct_translate.virt_to_phys_iter(
    &mut mem,
    &translator,
    addresses,
    &mut translated_data.from_extend(),
    &mut failed_translations.into(),
);


// We tried to translate one byte out of the mapped memory, it had to fail
assert_eq!(translated_data.len(), buffer_length - 1);

Provided methods

Translate a single virtual address

This function will do a virtual to physical memory translation for the VirtualTranslate3 for single address returning either PhysicalAddress, or an error.

Examples
use memflow::mem::{VirtualTranslate2, DirectTranslate};
use memflow::architecture::x86::x64;

let arch = x64::ARCH;

let mut direct_translate = DirectTranslate::new();

// Translate a mapped address
let res = direct_translate.virt_to_phys(
    &mut mem,
    &translator,
    virtual_base,
);

assert!(res.is_ok());

// Translate unmapped address
let res = direct_translate.virt_to_phys(
    &mut mem,
    &translator,
    virtual_base - 1,
);

assert!(res.is_err());

Implementors