Struct VolatileSlice 

pub struct VolatileSlice<'a, B = ()> { /* private fields */ }

A slice of raw memory that supports volatile access.

Implementations

impl<'a> VolatileSlice<'a, ()>

pub unsafe fn new(addr: *mut u8, size: usize) -> VolatileSlice<'a>

Creates a slice of raw memory that must support volatile access.

Safety

To use this safely, the caller must guarantee that the memory at addr is size bytes long and is available for the duration of the lifetime of the new VolatileSlice. The caller must also guarantee that all other users of the given chunk of memory are using volatile accesses.

impl<'a, B: BitmapSlice> VolatileSlice<'a, B>

pub unsafe fn with_bitmap( addr: *mut u8, size: usize, bitmap: B, mmap: Option<&'a MmapInfo>, ) -> VolatileSlice<'a, B>

Creates a slice of raw memory that must support volatile access, and uses the provided bitmap object for dirty page tracking.

Safety

To use this safely, the caller must guarantee that the memory at addr is size bytes long and is available for the duration of the lifetime of the new VolatileSlice. The caller must also guarantee that all other users of the given chunk of memory are using volatile accesses.

pub fn ptr_guard(&self) -> PtrGuard

Returns a guard for the pointer to the underlying memory.

pub fn ptr_guard_mut(&self) -> PtrGuardMut

Returns a mutable guard for the pointer to the underlying memory.

pub fn len(&self) -> usize

Gets the size of this slice.

pub fn is_empty(&self) -> bool

Checks if the slice is empty.

pub fn bitmap(&self) -> &B

Borrows the inner BitmapSlice.

pub fn split_at(&self, mid: usize) -> Result<(Self, Self)>

Divides one slice into two at an index.

Example

let vslice = VolatileSlice::from(&mut mem[..]);

let (start, end) = vslice.split_at(8).expect("Could not split VolatileSlice");
assert_eq!(8, start.len());
assert_eq!(24, end.len());

pub fn subslice(&self, offset: usize, count: usize) -> Result<Self>

Returns a subslice of this VolatileSlice starting at offset with count length.

The returned subslice is a copy of this slice with the address increased by offset bytes and the size set to count bytes.

pub fn offset(&self, count: usize) -> Result<VolatileSlice<'a, B>>

Returns a subslice of this VolatileSlice starting at offset.

The returned subslice is a copy of this slice with the address increased by count bytes and the size reduced by count bytes.

pub fn copy_to<T>(&self, buf: &mut [T]) -> usize

where T: ByteValued,

Copies as many elements of type T as possible from this slice to buf.

Copies self.len() or buf.len() times the size of T bytes, whichever is smaller, to buf. The copy happens from smallest to largest address in T sized chunks using volatile reads.

Examples

let mut mem = [0u8; 32];
let vslice = VolatileSlice::from(&mut mem[..]);
let mut buf = [5u8; 16];
let res = vslice.copy_to(&mut buf[..]);

assert_eq!(16, res);
for &v in &buf[..] {
    assert_eq!(v, 0);
}

pub fn copy_to_volatile_slice<S: BitmapSlice>( &self, slice: VolatileSlice<'_, S>, )

Copies as many bytes as possible from this slice to the provided slice.

The copies happen in an undefined order.

Examples

vslice.copy_to_volatile_slice(
    vslice
        .get_slice(16, 16)
        .expect("Could not get VolatileSlice"),
);

pub fn copy_from<T>(&self, buf: &[T])

where T: ByteValued,

Copies as many elements of type T as possible from buf to this slice.

The copy happens from smallest to largest address in T sized chunks using volatile writes.

Examples

let mut mem = [0u8; 32];
let vslice = VolatileSlice::from(&mut mem[..]);

let buf = [5u8; 64];
vslice.copy_from(&buf[..]);

for i in 0..4 {
    let val = vslice
        .get_ref::<u32>(i * 4)
        .expect("Could not get value")
        .load();
    assert_eq!(val, 0x05050505);
}

Trait Implementations

impl<B: BitmapSlice> Bytes<usize> for VolatileSlice<'_, B>

fn write(&self, buf: &[u8], addr: usize) -> Result<usize>

Examples

• Write a slice of size 5 at offset 1020 of a 1024-byte VolatileSlice.

let mut mem = [0u8; 1024];
let vslice = VolatileSlice::from(&mut mem[..]);
let res = vslice.write(&[1, 2, 3, 4, 5], 1020);

assert!(res.is_ok());
assert_eq!(res.unwrap(), 4);

fn read(&self, buf: &mut [u8], addr: usize) -> Result<usize>

Examples

• Read a slice of size 16 at offset 1010 of a 1024-byte VolatileSlice.

let mut mem = [0u8; 1024];
let vslice = VolatileSlice::from(&mut mem[..]);
let buf = &mut [0u8; 16];
let res = vslice.read(buf, 1010);

assert!(res.is_ok());
assert_eq!(res.unwrap(), 14);

fn write_slice(&self, buf: &[u8], addr: usize) -> Result<()>

Examples

• Write a slice at offset 256.

let res = vslice.write_slice(&[1, 2, 3, 4, 5], 256);

assert!(res.is_ok());
assert_eq!(res.unwrap(), ());

fn read_slice(&self, buf: &mut [u8], addr: usize) -> Result<()>

Examples

• Read a slice of size 16 at offset 256.

let buf = &mut [0u8; 16];
let res = vslice.read_slice(buf, 256);

assert!(res.is_ok());

type E = Error

Associated error codes

fn read_volatile_from<F>( &self, addr: usize, src: &mut F, count: usize, ) -> Result<usize>

where F: ReadVolatile,

Reads up to count bytes from src and writes them into the container at addr. Unlike VolatileRead::read_volatile, this function retries on EINTR being returned from the underlying I/O read operation.

fn read_exact_volatile_from<F>( &self, addr: usize, src: &mut F, count: usize, ) -> Result<()>

where F: ReadVolatile,

Reads exactly count bytes from an object and writes them into the container at addr.

fn write_volatile_to<F>( &self, addr: usize, dst: &mut F, count: usize, ) -> Result<usize>

where F: WriteVolatile,

Reads up to count bytes from the container at addr and writes them into dst. Unlike VolatileWrite::write_volatile, this function retries on EINTR being returned by the underlying I/O write operation.

fn write_all_volatile_to<F>( &self, addr: usize, dst: &mut F, count: usize, ) -> Result<()>

where F: WriteVolatile,

Reads exactly count bytes from the container at addr and writes them into an object.

fn store<T: AtomicAccess>( &self, val: T, addr: usize, order: Ordering, ) -> Result<()>

Atomically store a value at the specified address.

fn load<T: AtomicAccess>(&self, addr: usize, order: Ordering) -> Result<T>

Atomically load a value from the specified address.

fn write_obj<T: ByteValued>(&self, val: T, addr: A) -> Result<(), Self::E>

Writes an object into the container at addr.

fn read_obj<T: ByteValued>(&self, addr: A) -> Result<T, Self::E>

Reads an object from the container at addr.

impl<'a, B: Clone> Clone for VolatileSlice<'a, B>

fn clone(&self) -> VolatileSlice<'a, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, B: Debug> Debug for VolatileSlice<'a, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<&'a mut [u8]> for VolatileSlice<'a, ()>

fn from(value: &'a mut [u8]) -> Self

Converts to this type from the input type.

impl<'a, B: BitmapSlice> From<VolatileSlice<'a, B>> for VolatileArrayRef<'a, u8, B>

fn from(slice: VolatileSlice<'a, B>) -> Self

Converts to this type from the input type.

impl<B: BitmapSlice> VolatileMemory for VolatileSlice<'_, B>

type B = B

Type used for dirty memory tracking.

fn len(&self) -> usize

Gets the size of this slice.

fn get_slice(&self, offset: usize, count: usize) -> Result<VolatileSlice<'_, B>>

Returns a VolatileSlice of count bytes starting at offset.

fn is_empty(&self) -> bool

Check whether the region is empty.

fn as_volatile_slice(&self) -> VolatileSlice<'_, BS<'_, Self::B>>

Gets a slice of memory for the entire region that supports volatile access.

fn get_ref<T: ByteValued>( &self, offset: usize, ) -> Result<VolatileRef<'_, T, BS<'_, Self::B>>>

Gets a VolatileRef at offset.

fn get_array_ref<T: ByteValued>( &self, offset: usize, n: usize, ) -> Result<VolatileArrayRef<'_, T, BS<'_, Self::B>>>

Returns a VolatileArrayRef of n elements starting at offset.

unsafe fn aligned_as_ref<T: ByteValued>(&self, offset: usize) -> Result<&T>

Returns a reference to an instance of T at offset.

unsafe fn aligned_as_mut<T: ByteValued>(&self, offset: usize) -> Result<&mut T>

Returns a mutable reference to an instance of T at offset. Mutable accesses performed using the resulting reference are not automatically accounted for by the dirty bitmap tracking functionality.

fn get_atomic_ref<T: AtomicInteger>(&self, offset: usize) -> Result<&T>

Returns a reference to an instance of T at offset. Mutable accesses performed using the resulting reference are not automatically accounted for by the dirty bitmap tracking functionality.

fn compute_end_offset(&self, base: usize, offset: usize) -> Result<usize>

Returns the sum of base and offset if it is valid to access a range of offset bytes starting at base.

impl<'a, B: Copy> Copy for VolatileSlice<'a, B>