Struct memflow::mem::cache::cached_memory_access::CachedMemoryAccess

pub struct CachedMemoryAccess<'a, T, Q> { /* fields omitted */ }

The cache object that can use as a drop-in replacement for any Connector.

Since this cache implements PhysicalMemory it can be used as a replacement in all structs and functions that require a PhysicalMemory object.

Implementations

impl<'a, T: PhysicalMemory, Q: CacheValidator> CachedMemoryAccess<'a, T, Q>

pub fn new(mem: T, cache: PageCache<'a, Q>) -> Self

Constructs a new cache based on the given PageCache.

This function is used when manually constructing a cache inside of the memflow crate itself.

For general usage it is advised to just use the builder to construct the cache.

pub fn destroy(self) -> T

Consumes self and returns the containing memory object.

This function can be useful in case the ownership over the memory object has been given to the cache when it was being constructed. It will destroy the self and return back the ownership of the underlying memory object.

Examples

use memflow::architecture::x86::x64;
use memflow::mem::{PhysicalMemory, CachedMemoryAccess};

fn build<T: PhysicalMemory>(mem: T) -> T {
    let mut cache = CachedMemoryAccess::builder(mem)
        .arch(x64::ARCH)
        .build()
        .unwrap();

    // use the cache...
    let value: u64 = cache.phys_read(0.into()).unwrap();
    assert_eq!(value, MAGIC_VALUE);

    // retrieve ownership of mem and return it back
    cache.destroy()
}

impl<'a, T: PhysicalMemory> CachedMemoryAccess<'a, T, DefaultCacheValidator>

pub fn builder(mem: T) -> CachedMemoryAccessBuilder<T, DefaultCacheValidator>

Returns a new builder for this cache with default settings.

Trait Implementations

impl<'a, T, Q> Clone for CachedMemoryAccess<'a, T, Q> where
    T: Clone,
    Q: CacheValidator + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: PhysicalMemory, Q: CacheValidator> PhysicalMemory for CachedMemoryAccess<'a, T, Q>

fn phys_read_raw_list(
    &mut self,
    data: &mut [PhysicalReadData<'_>]
) -> Result<()>

fn phys_write_raw_list(&mut self, data: &[PhysicalWriteData<'_>]) -> Result<()>

fn metadata(&self) -> PhysicalMemoryMetadata

Retrieve metadata about the physical memory

fn phys_read_raw_into(
    &mut self,
    addr: PhysicalAddress,
    out: &mut [u8]
) -> Result<()>

fn phys_read_into<T: Pod + ?Sized>(
    &mut self,
    addr: PhysicalAddress,
    out: &mut T
) -> Result<()> where
    Self: Sized, 

fn phys_read_raw(
    &mut self,
    addr: PhysicalAddress,
    len: usize
) -> Result<Vec<u8>>

fn phys_read<T: Pod + Sized>(&mut self, addr: PhysicalAddress) -> Result<T> where
    Self: Sized, 

Safety

fn phys_write_raw(&mut self, addr: PhysicalAddress, data: &[u8]) -> Result<()>

fn phys_write<T: Pod + ?Sized>(
    &mut self,
    addr: PhysicalAddress,
    data: &T
) -> Result<()> where
    Self: Sized, 

fn phys_batcher(&mut self) -> PhysicalMemoryBatcher<'_, Self> where
    Self: Sized,