Enum Error 

pub enum Error {
    InvalidBootSignature {
        found: u16,
    },
    UnsupportedFatType(&'static str),
    InvalidFsInfoSignature {
        field: &'static str,
        expected: u32,
        found: u32,
    },
    InvalidShortFilename,
    ClusterOutOfBounds {
        cluster: u32,
        max: u32,
    },
    BadCluster {
        cluster: u32,
    },
    UnexpectedEndOfChain {
        cluster: u32,
    },
    Io(Error),
    IoContext {
        op: &'static str,
        sector: Option<u64>,
        source: Error,
    },
    CorruptFilesystem {
        context: &'static str,
    },
    ClusterLoop {
        cluster: u32,
    },
    NotAFile,
    NotADirectory,
    EntryNotFound,
    InvalidPath,
    NoFreeSpace,
    DirectoryFull,
    InvalidFilename,
    AlreadyExists,
    DirectoryNotEmpty,
    InvalidAttributeChange {
        bit: &'static str,
    },
    CacheDirtyEviction {
        sector: u32,
    },
    VolumeTooSmall {
        size: u64,
        min_size: u64,
    },
    VolumeTooLarge {
        size: u64,
        max_size: u64,
    },
    InvalidFormatOption {
        option: &'static str,
        reason: &'static str,
    },
}

Errors that can occur when working with FAT file systems.

Variants

InvalidBootSignature

Invalid boot signature (expected 0xAA55)

Fields

found: u16

The signature that was found

UnsupportedFatType(&'static str)

Unsupported FAT type (FAT12/16 when FAT32 expected, or vice versa)

InvalidFsInfoSignature

Invalid FSInfo signature

Fields

field: &'static str

Which signature field failed validation

expected: u32

The expected signature value

found: u32

The actual signature value found

InvalidShortFilename

Invalid short filename (contains disallowed characters)

ClusterOutOfBounds

Cluster number out of bounds

Fields

cluster: u32

The cluster number that was accessed

max: u32

The maximum valid cluster number

BadCluster

Bad cluster marker encountered

Fields

cluster: u32

The cluster marked as bad

UnexpectedEndOfChain

End of cluster chain reached unexpectedly

Fields

cluster: u32

The last cluster in the chain

Io(Error)

I/O error from the underlying storage

IoContext

I/O error annotated with the operation and (optionally) the sector where it happened. Used at trust boundaries — boot sector parse, FSInfo read, FAT chain walk entry, directory iteration head — so callers can tell which on-disk structure tripped the failure rather than just seeing an opaque Self::Io.

Fields

op: &'static str

Static label describing what was being read (e.g. "boot sector").

sector: Option<u64>

Sector where the failure originated, when known.

source: Error

The wrapped underlying I/O error.

CorruptFilesystem

On-disk arithmetic on an untrusted value would overflow or underflow.

The context string identifies which on-disk value triggered the failure (e.g. "sectors_per_fat * sector_size" when a corrupt BPB would push the FAT region past usize::MAX). This is distinct from ClusterOutOfBounds, which catches valid arithmetic that lands outside the cluster range.

Fields

context: &'static str

Static label describing which arithmetic check failed.

ClusterLoop

A FAT chain walk visited more clusters than the filesystem contains, which means the chain has a loop. Always corruption — a healthy chain is bounded by max_cluster - 1 (clusters 0 and 1 are reserved).

Fields

cluster: u32

The cluster the walker was inspecting when it hit the limit.

NotAFile

File is not a regular file (e.g., is a directory)

NotADirectory

Entry is not a directory

EntryNotFound

Entry not found in directory

InvalidPath

Path is invalid (empty, malformed)

NoFreeSpace

No free clusters available

DirectoryFull

Directory is full (no free entry slots)

InvalidFilename

Filename is invalid or too long

AlreadyExists

Entry with this name already exists

DirectoryNotEmpty

Cannot delete non-empty directory

InvalidAttributeChange

Attempted to flip an immutable attribute bit (DIRECTORY or VOLUME_ID) on an existing entry. Those bits identify the kind of entry on disk; changing them in-place would leave the cluster chain or root volume label inconsistent.

Fields

bit: &'static str

Which immutable bit the caller tried to flip.

CacheDirtyEviction

A read-only crate::cache::FatSectorCache operation needed to evict a sector to make room for a new one, but every cached sector is dirty. The caller must call crate::cache::FatSectorCache::flush (or crate::FatVolume::flush) before continuing — read paths can’t safely drop unwritten dirty data.

Fields

sector: u32

The dirty sector that would have been evicted.

VolumeTooSmall

Volume is too small for the requested format

Fields

size: u64

Requested volume size

min_size: u64

Minimum required size

VolumeTooLarge

Volume is too large for the requested FAT type

Fields

size: u64

Requested volume size

max_size: u64

Maximum supported size

InvalidFormatOption

Invalid format option

Fields

option: &'static str

The option that was invalid

reason: &'static str

The reason it was invalid

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

Available on crate feature std only.

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<E: IoError> From<Error<E>> for Error

fn from(e: Error<E>) -> Self

Converts to this type from the input type.