Struct redox_buffer_pool::BufferSlice

pub struct BufferSlice<'a, I: Integer, H: Handle, E: Copy, G: Guard = NoGuard> { /* fields omitted */ }

A slice from the buffer pool, that can be read from or written to as a regular smart pointer.

Implementations

impl<'a, I, H, E, G> BufferSlice<'a, I, H, E, G> where
    I: Integer,
    H: Handle,
    E: Copy,
    G: Guard, 

pub fn pool_is_alive(&self) -> bool

Checks whether the pool that owns this slice is still alive, or if it has dropped. Note that this only makes sense for weak buffer slices, since buffer slices tied to a lifetime cannot outlive their pools (checked for at compile time), while strong buffer slices ensure at runtime that they outlive their pools.

For weak buffer slices, this method should be called before doing anything with the slice, since a single deref could make it panic if the buffer isn't there anymore.

pub fn as_slice(&self) -> &[u8]

Construct an immutable slice from this buffer.

Panics

This method will panic if this is a weak slice, and the buffer pool has been destroyed..

pub fn try_as_slice(&self) -> Option<&[u8]>

Tries to construct an immutable slice from this buffer, returning None if the pool has been dropped (and hence, this is a weak slice).

pub fn as_slice_mut(&mut self) -> &mut [u8]

Construct a mutable slice from this buffer.

Panics

Like as_slice, this method will panic if the buffer pool has been destroyed.

pub fn try_as_slice_mut(&mut self) -> Option<&mut [u8]>

Tries to construct a mutable slice from this buffer, returning None if the pool has been destroyed.

pub unsafe fn unguard(&mut self) -> Option<G>

Forcefully remove a guard from a future, from this slice, returning it if there was a guard already.

Safety

This is unsafe because it allows removing guards set by pending futures; although this is completely fine when there are no pending ones, the buffer slice will be reclaimed without the guard, causing UB if any producer keeps using its pointer.

pub fn guard(&mut self, guard: G) -> Result<(), WithGuardError<G>>

Adds a guard to this buffer, preventing it from deallocating unless the guard accepts that. This is crucial when memory is shared with another component that may be outside this process's address space. If there is a pending io_uring submission or a pending NVME command for instance, this guard will fail if the buffer is in use by a command, and leak the memory instead when dropping.

This will error with WithGuardError if there is already an active guard.

pub fn with_guard<OtherGuard: Guard>(
    self,
    other: OtherGuard
) -> Result<BufferSlice<'a, I, H, E, OtherGuard>, WithGuardError<Self>>

Tries to add a guard of potentially a different type than the guard type in this slice. Because of that this, this will consume self and construct a different BufferSlice with a different guard type, or error with self if there was already a guard present.

pub fn reclaim(self) -> Result<(), ReclaimError<Self>>

Reclaim the buffer slice, equivalent to dropping but with a Result. If the buffer slice was guarded by a future, this will fail with ReclaimError if the future hadn't completed when this was called.

pub fn offset(&self) -> I

Get the offset of the buffer pool where this was allocated.

pub fn len(&self) -> I

Get the length of the allocation slice.

pub fn capacity(&self) -> I

Get the capacity of the allocation slice. This is almost always the same as the length, but may be larger in case the allocator chose a larger size to align the range afterwards.

pub fn is_empty(&self) -> bool

Check whether the slice is empty or not.

pub fn mmap_offset(&self) -> I

Get the offset of the underlying possibly non-continuously-organized mmap, that was added as part of BufferPool::begin_expand.

pub fn mmap_size(&self) -> I

Get the size of the mmap region this slice was allocated in.

pub fn extra(&self) -> E

Get the extra field from the mmap region this slice belongs to, copied.

Trait Implementations

impl<'a, I: Integer, H: Handle, E: Copy, G: Guard> AsMut<[u8]> for BufferSlice<'a, I, H, E, G>

fn as_mut(&mut self) -> &mut [u8]

Performs the conversion.

impl<'a, I: Integer, H: Handle, E: Copy, G: Guard> AsRef<[u8]> for BufferSlice<'a, I, H, E, G>

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl<'a, I: Integer, H: Handle, E: Copy, G: Guard> Borrow<[u8]> for BufferSlice<'a, I, H, E, G>

fn borrow(&self) -> &[u8]

Immutably borrows from an owned value.

impl<'a, I: Integer, H: Handle, E: Copy, G: Guard> BorrowMut<[u8]> for BufferSlice<'a, I, H, E, G>

fn borrow_mut(&mut self) -> &mut [u8]

Mutably borrows from an owned value.

impl<'a, I: Debug + Integer, H: Debug + Handle, E: Debug + Copy, G: Debug + Guard> Debug for BufferSlice<'a, I, H, E, G>

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

Formats the value using the given formatter.

impl<'a, I: Integer, H: Handle, E: Copy, G: Guard> Deref for BufferSlice<'a, I, H, E, G>

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, I: Integer, H: Handle, E: Copy, G: Guard> DerefMut for BufferSlice<'a, I, H, E, G>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, I, H, E, G> Drop for BufferSlice<'a, I, H, E, G> where
    I: Integer,
    G: Guard,
    E: Copy,
    H: Handle, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, I, H, E, G> Send for BufferSlice<'a, I, H, E, G> where
    I: Integer,
    H: Send + Sync + Handle,
    E: Copy + Send,
    G: Send + Guard, 

impl<'a, I, H, E, G> Sync for BufferSlice<'a, I, H, E, G> where
    I: Integer,
    H: Send + Sync + Handle,
    E: Copy + Sync,
    G: Sync + Guard,