Enum IoError 

pub enum IoError {
    BufferTooBig {
        size: u64,
        backtrace: BackTrace,
    },
    OutOfMemory {
        size: u64,
        backtrace: BackTrace,
    },
    PoolCapacityExceeded {
        size: u64,
        capacity: u64,
        in_use: u64,
        backtrace: BackTrace,
    },
    UnsupportedStrides {
        backtrace: BackTrace,
    },
    NotFound {
        backtrace: BackTrace,
        reason: Reason,
    },
    StorageHandleNotFound {
        reason: Reason,
        backtrace: BackTrace,
    },
    StorageMappingFailed {
        size: u64,
        source: Box<IoError>,
        backtrace: BackTrace,
    },
    FreeError {
        backtrace: BackTrace,
    },
    Unknown {
        description: String,
        backtrace: BackTrace,
    },
    UnsupportedIoOperation {
        backtrace: BackTrace,
    },
    Execution(Box<ServerError>),
}

Error returned from create/read/write functions. Due to async execution not all errors are able to be caught, so some IO errors will still panic.

Variants

BufferTooBig

Buffer size exceeds the max available

Fields

size: u64

The size of the buffer in bytes.

backtrace: BackTrace

The captured backtrace.

OutOfMemory

The device had no memory left for this allocation.

Unlike IoError::BufferTooBig (the allocation can never fit), this describes the device at one moment: pool pages whose slices have all been dropped are still resident, and the frees that would release them may not have reached the driver yet. Reclaiming and retrying is a reasonable response, which is why a storage backend must not report a driver out-of-memory as BufferTooBig: that tells every caller the allocation is hopeless when it is merely untimely.

Fields

size: u64

The size of the failed allocation in bytes.

backtrace: BackTrace

The captured backtrace.

PoolCapacityExceeded

A memory pool with a fixed capacity cap is exhausted.

Unlike IoError::BufferTooBig (the allocation can never fit), this means the working set exceeded the configured budget. Server execution paths treat it as fatal — the budget is a hard contract, so failing early beats silently growing — but callers that manage their own working set may free pool memory and retry.

Fields

size: u64

The size of the failed reservation in bytes.

capacity: u64

The configured pool capacity in bytes (whole pages).

in_use: u64

Bytes currently in use in the pool.

backtrace: BackTrace

The captured backtrace.

UnsupportedStrides

Strides aren’t supported for this copy operation on this runtime

Fields

backtrace: BackTrace

The backtrace.

NotFound

Memory wasn’t found in the memory pool

Fields

backtrace: BackTrace

The backtrace.

reason: Reason

The reason the handle is invalid.

StorageHandleNotFound

The storage backend holds no allocation for a handle’s storage id.

One layer below IoError::NotFound: there the memory manager could not route a binding to a slice, here the routing succeeded and the allocation the slice names is gone. A handle outliving its page, or a storage id a deallocation retired, reaches the storage this way.

Fields

reason: Reason

Which id was looked up, and in which storage.

backtrace: BackTrace

The backtrace.

StorageMappingFailed

An allocation carved lazily under a DryRun could not be given real device backing when it was finally resolved.

Distinct from the same failure at reservation time, and the distinction is what a caller acts on: the memory was promised earlier, by a pass that measured a plan without paying for it, and is only now being charged for. A plan whose replay hits this was measured against more device memory than the replay has — warm the tune caches first, or measure a smaller one.

Fields

size: u64

The size of the allocation that could not be backed, in bytes.

source: Box<IoError>

Why the device allocation failed.

backtrace: BackTrace

The backtrace.

FreeError

Handle wasn’t found in the memory pool

Fields

backtrace: BackTrace

The backtrace.

Unknown

Unknown error happened during execution

Fields

description: String

Details of the error

backtrace: BackTrace

The backtrace.

UnsupportedIoOperation

The current IO operation is not supported

Fields

backtrace: BackTrace

The backtrace.

Execution(Box<ServerError>)

Can’t perform the IO operation because of a runtime error.

Trait Implementations

impl Clone for IoError

fn clone(&self) -> IoError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IoError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IoError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for IoError

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

Formats the value using the given formatter.

impl Error for IoError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Box<ServerError>> for IoError

fn from(source: Box<ServerError>) -> Self

Converts to this type from the input type.

impl From<IoError> for LaunchError

fn from(source: IoError) -> Self

Converts to this type from the input type.

impl From<IoError> for ServerError

fn from(source: IoError) -> Self

Converts to this type from the input type.

impl Serialize for IoError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.