Struct memflow::mem::memory_view::cached_view::CachedViewBuilder

pub struct CachedViewBuilder<T, Q> { /* private fields */ }

Implementations

impl<T: MemoryView> CachedViewBuilder<T, DefaultCacheValidator>

pub fn new(mem: T) -> Self

Creates a new CachedView builder. The memory object is mandatory as the CachedView struct wraps around it.

This type of cache also is required to know the exact page size of the target system. This can either be set directly via the page_size() method or via the arch() method. If no page size has been set this builder will fail to build the CachedView.

Without further adjustments this function creates a cache that is 2 megabytes in size and caches pages that contain pagetable entries as well as read-only pages.

It is also possible to either let the CachedView object own or just borrow the underlying memory object.

Examples

Moves ownership of a mem object and retrieves it back:

use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;

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

let mut cached_mem = CachedView::builder(virt_mem)
    .arch(x64::ARCH)
    .build()
    .unwrap();

let addr = virt_base; // some arbitrary address

cached_mem.write(addr, &MAGIC_VALUE).unwrap();

let value: u64 = cached_mem.read(addr).unwrap();
assert_eq!(value, MAGIC_VALUE);

Borrowing a mem object:

use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;

fn build<T: MemoryView>(mem: Fwd<&mut T>)
    -> impl MemoryView + '_ {
    CachedView::builder(mem)
        .arch(x64::ARCH)
        .build()
        .unwrap()
}

let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let mut cached_view = build(virt_mem.forward_mut());

let read = cached_view.read::<u32>(0.into()).unwrap();

impl<T: MemoryView, Q: CacheValidator> CachedViewBuilder<T, Q>

pub fn build<'a>(self) -> Result<CachedView<'a, T, Q>>

Builds the CachedView object or returns an error if the page size is not set.

pub fn validator<QN: CacheValidator>( self, validator: QN ) -> CachedViewBuilder<T, QN>

Sets a custom validator for the cache.

If this function is not called it will default to a DefaultCacheValidator. The default validator for std builds is the [TimedCacheValidator]. The default validator for no_std builds is the [CountCacheValidator].

The default setting is DefaultCacheValidator::default().

Examples:

use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
use std::time::Duration;

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

let mut cached_mem = CachedView::builder(virt_mem)
    .arch(x64::ARCH)
    .validator(DefaultCacheValidator::new(Duration::from_millis(2000).into()))
    .build()
    .unwrap();

let addr = virt_base; // some arbitrary address

cached_mem.write(addr, &MAGIC_VALUE).unwrap();

let value: u64 = cached_mem.read(addr).unwrap();
assert_eq!(value, MAGIC_VALUE);

pub fn page_size(self, page_size: usize) -> Self

Changes the page size of the cache.

The cache has to know the exact page size of the target system internally to give reasonable performance. The page size can be either set directly via this function or it can be fetched from the Architecture via the arch() method of the builder.

If the page size is not set the builder will fail.

Examples

use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;

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

let mut cached_mem = CachedView::builder(virt_mem)
    .page_size(size::kb(4))
    .build()
    .unwrap();

let addr = virt_base; // some arbitrary address

cached_mem.write(addr, &MAGIC_VALUE).unwrap();

let value: u64 = cached_mem.read(addr).unwrap();
assert_eq!(value, MAGIC_VALUE);

pub fn arch(self, arch: impl Into<ArchitectureObj>) -> Self

Retrieves the page size for this cache from the given Architecture.

The cache has to know the exact page size of the target system internally to give reasonable performance. The page size can be either fetched from the Architecture via this method or it can be set directly via the page_size() method of the builder.

If the page size is not set the builder will fail.

Examples

use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;

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

let mut cached_mem = CachedView::builder(virt_mem)
    .arch(x64::ARCH)
    .build()
    .unwrap();

let addr = virt_base; // some arbitrary address

cached_mem.write(addr, &MAGIC_VALUE).unwrap();

let value: u64 = cached_mem.read(addr).unwrap();
assert_eq!(value, MAGIC_VALUE);

pub fn cache_size(self, cache_size: usize) -> Self

Sets the total amount of cache to be used.

This is the total amount of cache (in bytes) this page cache will allocate. Ideally you’d want to keep this value low enough so that most of the cache stays in the lower level caches of your cpu.

The default setting is 2 megabytes.

This setting can drastically impact the performance of the cache.

Examples:

use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;

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

let mut cached_mem = CachedView::builder(virt_mem)
    .arch(x64::ARCH)
    .cache_size(size::mb(2))
    .build()
    .unwrap();

let addr = virt_base; // some arbitrary address

cached_mem.write(addr, &MAGIC_VALUE).unwrap();

let value: u64 = cached_mem.read(addr).unwrap();
assert_eq!(value, MAGIC_VALUE);