Struct base::volatile_memory::VolatileSlice

source ·

#[repr(transparent)]
pub struct VolatileSlice<'a>(IoBufMut<'a>);

Expand description

A slice of raw memory that supports volatile access. Like std::io::IoSliceMut, this type is guaranteed to be ABI-compatible with libc::iovec but unlike IoSliceMut, it doesn’t automatically deref to &mut [u8].

Tuple Fields§

§0: IoBufMut<'a>

Implementations§

source §

impl<'a> VolatileSlice<'a>

source

pub fn new(buf: &mut [u8]) -> VolatileSlice<'_>

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

source

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

Creates a VolatileSlice from a pointer and a length.

Safety

In order to use this method safely, addr must be valid for reads and writes of len bytes and should live for the entire duration of lifetime 'a.

source

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

Gets a const pointer to this slice’s memory.

source

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

Gets a mutable pointer to this slice’s memory.

source

pub fn size(&self) -> usize

Gets the size of this slice.

source

pub fn advance(&mut self, count: usize)

Advance the starting position of this slice.

Panics if count > self.size().

source

pub fn truncate(&mut self, len: usize)

Shorten the length of the slice.

Has no effect if len > self.size().

source

pub fn as_iobuf(&self) -> &IoBufMut<'_>

Returns this VolatileSlice as an IoBufMut.

source

pub fn as_iobufs<'mem, 'slice>( iovs: &'slice [VolatileSlice<'mem>] ) -> &'slice [IoBufMut<'mem>]

Converts a slice of VolatileSlices into a slice of IoBufMuts

source

pub fn as_iobufs_mut<'mem, 'slice>( iovs: &'slice mut [VolatileSlice<'mem>] ) -> &'slice mut [IoBufMut<'mem>]

Converts a mutable slice of VolatileSlices into a mutable slice of IoBufMuts

source

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

Creates a copy of this slice with the address increased by count bytes, and the size reduced by count bytes.

source

pub fn sub_slice( self, offset: usize, count: usize ) -> VolatileMemoryResult<VolatileSlice<'a>>

Similar to get_slice but the returned slice outlives this slice.

The returned slice’s lifetime is still limited by the underlying data’s lifetime.

source

pub fn write_bytes(&self, value: u8)

Sets each byte of this slice with the given byte, similar to memset.

The bytes of this slice are accessed in an arbitray order.

Examples

let mut mem = [0u8; 32];
let vslice = VolatileSlice::new(&mut mem[..]);
vslice.write_bytes(45);
for &v in &mem[..] {
    assert_eq!(v, 45);
}

source

pub fn copy_to<T>(&self, buf: &mut [T])where T: FromBytes + AsBytes + Copy,

Copies self.size() 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::new(&mut mem[..]);
let mut buf = [5u8; 16];
vslice.copy_to(&mut buf[..]);
for v in &buf[..] {
    assert_eq!(buf[0], 0);
}

source

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

Copies self.size() or slice.size() bytes, whichever is smaller, to slice.

The copies happen in an undefined order.

Examples

let mut mem = [0u8; 32];
let vslice = VolatileSlice::new(&mut mem[..]);
vslice.copy_to_volatile_slice(vslice.get_slice(16, 16).map_err(|_| ())?);

source

pub fn copy_from<T>(&self, buf: &[T])where T: FromBytes + AsBytes,

Copies self.size() or buf.len() times the size of T bytes, whichever is smaller, to this slice’s memory.

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

Examples

let mut mem = [0u8; 32];
let vslice = VolatileSlice::new(&mut mem[..]);
let buf = [5u8; 64];
vslice.copy_from(&buf[..]);
let mut copy_buf = [0u32; 4];
vslice.copy_to(&mut copy_buf);
for i in 0..4 {
    assert_eq!(copy_buf[i], 0x05050505);
}