Struct vm_memory::volatile_memory::VolatileSlice

pub struct VolatileSlice<'a> { /* fields omitted */ }

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.

pub fn as_ptr(&self) -> *mut u8

Returns a pointer to the beginning of the slice.

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 split_at(
    self,
    mid: usize
) -> Result<(VolatileSlice<'a>, VolatileSlice<'a>)>

Divides one slice into two at an index.

Example

let vslice = mem_ref
    .get_slice(0, 32)
    .expect("Could not get VolatileSlice");

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<VolatileSlice<'a>>

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

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 mem_ref = &mut mem[..];
let vslice = mem_ref
    .get_slice(0, 32)
    .expect("Could not get VolatileSlice");
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(&self, slice: VolatileSlice<'_>)

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 mem_ref = &mut mem[..];
let vslice = mem_ref
    .get_slice(0, 32)
    .expect("Could not get VolatileSlice");

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 Bytes<usize> for VolatileSlice<'_>

type E = Error

Associated error codes

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 mut mem_ref = &mut mem[..];
let vslice = mem_ref.as_volatile_slice();
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 mut mem_ref = &mut mem[..];
let vslice = mem_ref.as_volatile_slice();
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());

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

Examples

• Read bytes from /dev/urandom

let mut file = File::open(Path::new("/dev/urandom")).expect("Could not open /dev/urandom");

vslice
    .read_from(32, &mut file, 128)
    .expect("Could not read bytes from file into VolatileSlice");

let rand_val: u32 = vslice
    .read_obj(40)
    .expect("Could not read value from VolatileSlice");

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

Examples

• Read bytes from /dev/urandom

let mut file = File::open(Path::new("/dev/urandom")).expect("Could not open /dev/urandom");

vslice
    .read_exact_from(32, &mut file, 128)
    .expect("Could not read bytes from file into VolatileSlice");

let rand_val: u32 = vslice
    .read_obj(40)
    .expect("Could not read value from VolatileSlice");

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

Examples

• Write 128 bytes to /dev/null

let mut file = OpenOptions::new()
    .write(true)
    .open("/dev/null")
    .expect("Could not open /dev/null");

vslice
    .write_to(32, &mut file, 128)
    .expect("Could not write value from VolatileSlice to /dev/null");

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

Examples

• Write 128 bytes to /dev/null

let mut file = OpenOptions::new()
    .write(true)
    .open("/dev/null")
    .expect("Could not open /dev/null");

vslice
    .write_all_to(32, &mut file, 128)
    .expect("Could not write value from VolatileSlice to /dev/null");

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> Clone for VolatileSlice<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for VolatileSlice<'a>

impl<'a> Debug for VolatileSlice<'a>

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

Formats the value using the given formatter.

impl<'a> From<VolatileSlice<'a>> for VolatileArrayRef<'a, u8>

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

Performs the conversion.

impl VolatileMemory for VolatileSlice<'_>

fn len(&self) -> usize

Gets the size of this slice.

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

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<'_>

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

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

Gets a VolatileRef at offset.

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

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.

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

Returns a reference to an instance of T at offset.

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

Returns the sum of base and offset if the resulting address is valid.