Filesystems can abilities a minimal of three varied kinds of errors

March 11, 2022

The day past I wrote about the design in which it can perhaps be tremendous if Linux exposed a count
of disk errors and mentioned that
some Linux filesystems conclude repeat such a count of errors, nonetheless it’s now not
obvious what function of errors they mean. This sounds luxuriate in a weird and wonderful ingredient
to articulate, however truly filesystems can abilities a minimal of two or three
varied kinds of errors. I will call these I/O errors, integrity
errors, and structural errors.

An I/O error happens when the underlying storage instrument returns an
error from a learn or a write operation. Some filesystems enjoy some
interior redundancy that could perhaps screen such errors that happen in one of the best
function of locations, however more often than not here’s a command particular person error that
will correspond to an I/O error that’s (confidently) reported by the
storage instrument. Thanks to this on the total command hyperlink between a decrease
degree error and a filesystem error, a filesystem could perhaps also decide now not to tune
and record these errors, in particular after they happen whereas learning particular person
info as a alternative of filesystem metadata.

An integrity error happens when the filesystem has some function of
checksums over (a pair of of) its on disk info, and the recorded checksum
fails to study what it will nonetheless be in line with the details the filesystem got
from the storage instrument. ZFS is
accepted for having checksums on each particular person info and filesystem metadata,
even though it’s now not essentially the most easy filesystem to total this. There are other
filesystems that enjoy checksums that easiest apply to filesystem metadata.
Virtually all storage devices enjoy some extent of undetected bit corruption,
and checksums can furthermore detect varied other kinds of disk wound (such
as misdirected writes).

A structural error happens when the filesystem detects that some
of its on-disk metadata is now not finest, in any of the assorted particular
ways for any particular function of metadata to be unsuitable. Often
this happens because on-disk info has been corrupted, however infrequently
it happens because the filesystem code has bugs that introduced about one thing
unsuitable and invalid to be written out to disk (in which case the
metadata could perhaps even enjoy completely agreeable checksums or other integrity tests).
A filesystem that counts errors and can ogle integrity errors on
metadata could perhaps also now not desire to double count such errors as structural errors
as successfully.

Given all of this, you would also peep that a filesystem that counts ‘errors’
without being more particular is extremely unclear. Is this a count of all
errors that the filesystem can detect, at the side of I/O errors? Is this
a count of all structural errors no matter their cause, even when
they reach from detected (and logged) I/O errors or integrity errors? If
a filesystem counts integrity errors by hook or by crook, does that count consist of
failed integrity tests which a minimal of implicitly happen when there are
I/O errors?

(There are scenarios the keep you would also abilities I/O errors on I/O that
that’s easiest important to test the integrity, now not to reach aid the
requested info. Additionally, you will reasonably count this as each an I/O error
and an integrity error, as in opposition to the subject the keep you’ve got an
I/O error on info that’s straight important.)

Any given filesystem that reports or counts errors goes to enjoy an
acknowledge to all of these questions, however there could be no such thing as a single net page of apparent
and clearly finest solutions. It varies on a filesystem by filesystem
basis, so in the event you easiest hear that a filesystem is reporting ‘errors’, you
fabricate now not know as a lot about what it’s reporting as you would also bear in mind.