VirtualTranslate2

memflow::mem::virt_translate

Trait VirtualTranslate2 

Source 
pub trait VirtualTranslate2
where
    Self: Send,
{
    // Required method
    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>>;

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

Required Methods§

Source

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>>,

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§

Source

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

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());

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§