Enum KernelError 

pub enum KernelError {
    OutOfMemory {
        requested: usize,
        available: usize,
    },
    InvalidAddress {
        addr: usize,
    },
    UnmappedMemory {
        addr: usize,
    },
    InvalidCapability {
        cap_id: u64,
        reason: CapError,
    },
    InsufficientRights {
        required: u16,
        actual: u16,
    },
    CapabilityRevoked {
        cap_id: u64,
    },
    ProcessNotFound {
        pid: u64,
    },
    ThreadNotFound {
        tid: u64,
    },
    InvalidState {
        expected: &'static str,
        actual: &'static str,
    },
    IpcError(IpcError),
    SchedulerError(SchedError),
    SyscallError(SyscallError),
    FsError(FsError),
    HardwareError {
        device: &'static str,
        code: u32,
    },
    InvalidArgument {
        name: &'static str,
        value: &'static str,
    },
    OperationNotSupported {
        operation: &'static str,
    },
    ResourceExhausted {
        resource: &'static str,
    },
    PermissionDenied {
        operation: &'static str,
    },
    AlreadyExists {
        resource: &'static str,
        id: u64,
    },
    NotFound {
        resource: &'static str,
        id: u64,
    },
    Timeout {
        operation: &'static str,
        duration_ms: u64,
    },
    NotImplemented {
        feature: &'static str,
    },
    WouldBlock,
    BrokenPipe,
    NotInitialized {
        subsystem: &'static str,
    },
    LegacyError {
        message: &'static str,
    },
}

Main kernel error type

Variants

OutOfMemory

Memory-related errors

Fields

requested: usize

available: usize

InvalidAddress

Fields

addr: usize

UnmappedMemory

Fields

addr: usize

InvalidCapability

Capability-related errors

Fields

cap_id: u64

reason: CapError

InsufficientRights

Fields

required: u16

actual: u16

CapabilityRevoked

Fields

cap_id: u64

ProcessNotFound

Process-related errors

Fields

pid: u64

ThreadNotFound

Fields

tid: u64

InvalidState

Fields

expected: &'static str

actual: &'static str

IpcError(IpcError)

IPC-related errors

SchedulerError(SchedError)

Scheduler-related errors

SyscallError(SyscallError)

System call errors

FsError(FsError)

Filesystem-related errors

HardwareError

Hardware errors

Fields

device: &'static str

code: u32

InvalidArgument

Generic errors

Fields

name: &'static str

value: &'static str

OperationNotSupported

Fields

operation: &'static str

ResourceExhausted

Fields

resource: &'static str

PermissionDenied

Fields

operation: &'static str

AlreadyExists

Fields

resource: &'static str

id: u64

NotFound

Fields

resource: &'static str

id: u64

Timeout

Fields

operation: &'static str

duration_ms: u64

NotImplemented

Fields

feature: &'static str

WouldBlock

Operation would block

BrokenPipe

Broken pipe: write end closed or read end closed

NotInitialized

Subsystem not initialized (called before init())

Fields

subsystem: &'static str

LegacyError

Legacy string error for gradual migration from &’static str patterns. New code should use specific error variants instead.

Fields

message: &'static str

Trait Implementations

impl Clone for KernelError

fn clone(&self) -> KernelError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KernelError

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

Formats the value using the given formatter.

impl Display for KernelError

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

Formats the value using the given formatter.

impl From<&'static str> for KernelError

Conversion from legacy &’static str errors to KernelError.

This enables gradual migration: functions returning Result<T, &’static str> can be called with ? from functions returning Result<T, KernelError>. New code should prefer specific error variants over this conversion.

fn from(msg: &'static str) -> Self

Converts to this type from the input type.

impl From<BondError> for KernelError

fn from(_e: BondError) -> Self

Converts to this type from the input type.

impl From<CapError> for KernelError

fn from(err: CapError) -> Self

Converts to this type from the input type.

impl From<FsError> for KernelError

fn from(err: FsError) -> Self

Converts to this type from the input type.

impl From<IpcError> for KernelError

fn from(err: IpcError) -> Self

Converts to this type from the input type.

impl From<SchedError> for KernelError

fn from(err: SchedError) -> Self

Converts to this type from the input type.

impl From<SyscallError> for KernelError

fn from(err: SyscallError) -> Self

Converts to this type from the input type.

impl From<VmError> for KernelError

fn from(e: VmError) -> Self

Converts to this type from the input type.

impl From<WaylandError> for KernelError

fn from(e: WaylandError) -> Self

Converts to this type from the input type.

impl PartialEq for KernelError

fn eq(&self, other: &KernelError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for KernelError

impl Eq for KernelError

impl StructuralPartialEq for KernelError