Struct fuse_backend_rs::common::file_buf::FileVolatileSlice

pub struct FileVolatileSlice<'a> { /* private fields */ }

An adapter structure to work around limitations of the vm-memory crate.

It solves the compilation failure by masking out the vm_memory::BitmapSlice generic type parameter of vm_memory::VolatileSlice.

Implementations

impl<'a> FileVolatileSlice<'a>

pub unsafe fn from_raw_ptr(addr: *mut u8, size: usize) -> Self

Create a new instance of FileVolatileSlice from a raw pointer.

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 FileVolatileSlice. The caller must also guarantee that all other users of the given chunk of memory are using volatile accesses.

Example

let mut buffer = [0u8; 1024];
let s = unsafe { FileVolatileSlice::from_raw_ptr(buffer.as_mut_ptr(), buffer.len()) };

{
    let o: u32 = s.load(0x10, Ordering::Acquire).unwrap();
    assert_eq!(o, 0);
    s.store(1u8, 0x10, Ordering::Release).unwrap();

    let s2 = s.as_volatile_slice();
    let s3 = FileVolatileSlice::from_volatile_slice(&s2);
    assert_eq!(s3.len(), 1024);
}

assert_eq!(buffer[0x10], 1);

pub unsafe fn from_mut_slice(buf: &'a mut [u8]) -> Self

Create a new instance of FileVolatileSlice from a mutable slice.

Safety

The caller must guarantee that all other users of the given chunk of memory are using volatile accesses.

pub fn from_volatile_slice<S: BitmapSlice>(s: &VolatileSlice<'a, S>) -> Self

Create a new FileVolatileSlice from vm_memory::VolatileSlice and strip off the vm_memory::BitmapSlice.

The caller needs to handle dirty page tracking for the data buffer.

pub fn as_volatile_slice(&self) -> VolatileSlice<'a, ()>

Create a vm_memory::VolatileSlice from FileVolatileSlice without dirty page tracking.

pub unsafe fn borrow_as_buf(&self, inited: bool) -> FileVolatileBuf

Borrow as a FileVolatileSlice object to temporarily elide the lifetime parameter.

Safety

The FileVolatileSlice is borrowed without a lifetime parameter, so the caller must ensure that FileVolatileBuf doesn’t out-live the borrowed FileVolatileSlice object.

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

Return a pointer to the start of the slice.

pub fn len(&self) -> usize

Get the size of the slice.

pub fn is_empty(&self) -> bool

Check if the slice is empty.

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

Return a subslice of this FileVolatileSlice starting at offset.

Trait Implementations

impl<'a> Bytes<usize> for FileVolatileSlice<'a>

type E = Error

Associated error codes

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

Writes a slice into the container at addr.

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

Reads data from the container at addr into a slice.

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

Writes the entire content of a slice into the container at addr.

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

Reads data from the container at addr to fill an entire slice.

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

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

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

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

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

Reads up to count bytes from the container at addr and writes them it into an object.

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

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<(), Self::E>

Atomically store a value at the specified address.

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

Atomically load a value from the specified address.

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

Writes an object into the container at addr.

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

Reads an object from the container at addr.

impl<'a> Clone for FileVolatileSlice<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for FileVolatileSlice<'a>

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

Formats the value using the given formatter.

impl<'a> Copy for FileVolatileSlice<'a>