feat(fs): statfs without an allocator, on every driver and generically

`fs::StatFs` moves out of the alloc-only API into a module compiled in
every configuration (same path, `fstool::fs::StatFs`), gains
`total_bytes` / `free_bytes` / `avail_bytes`, and derives `PartialEq`/`Eq`.

The allocator-free FAT, exFAT and littlefs volumes answer
`statfs(&mut self)` with it in their own allocation units — clusters or
erase blocks — and `fs::volume::Volume` has it too, so `AnyVolume` does.
The trait method is provided (derived from `total_bytes` / `free_bytes`
in 512-byte units), so implementations written against 0.4.32 keep
compiling.

Checked against the tools: the counts match what `fsck.vfat` walks out of
the FAT, what `dump.exfat` reads from the bitmap, and littlefs's own
used-block traversal through `littlefs-python`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: MagicalTux

CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- *(fs)* `Volume::statfs` on the allocator-free FAT, exFAT and littlefs
+  drivers, and on the `fs::volume::Volume` trait (so on `AnyVolume` too):
+  capacity in `statfs` shape — the allocation unit (cluster or erase block),
+  how many there are and how many are free, and the longest name. It
+  answers with the same `fs::StatFs` the hosted `Filesystem::statfs` does,
+  which is now compiled in every configuration, not only with `alloc`, and
+  gains `total_bytes` / `free_bytes` / `avail_bytes`. The counts agree with
+  what `fsck.vfat` and `dump.exfat` work out from the volume, and with
+  littlefs's own traversal through `littlefs-python`. The trait method is
+  provided — derived from `total_bytes` / `free_bytes` in 512-byte units —
+  so an implementation written against 0.4.32 still compiles.
+
+### Changed
+
+- *(fs)* `StatFs` derives `PartialEq` and `Eq`.
+
 ## [0.4.32](https://github.com/KarpelesLab/fstool/compare/v0.4.31...v0.4.32) - 2026-09-15
 
 ### Added

README.md

@@ -981,6 +981,11 @@ fn on_insert(card: SdCard) -> Result<SdCard, fstool::fs::volume::AnyError<MyDriv
 }
 ```
 
+`statfs()` answers capacity the same way on every one of them — the
+`fs::StatFs` struct the hosted `Filesystem::statfs` returns, compiled without
+a heap: allocation unit, units in all and free, longest name, plus
+`total_bytes()` / `free_bytes()` helpers.
+
 Errors keep their driver's detail — `AnyError::Fat(fat::Error::NoSpace)` —
 and every one of them also answers `kind()` with a shared `ErrorKind`, so
 generic code can tell `NotFound` from `Io` without knowing whose error it

src/fs/api.rs

@@ -23,6 +23,8 @@ use alloc::string::String;
 use alloc::vec;
 use alloc::vec::Vec;
 
+use super::StatFs;
+
 #[cfg(feature = "std")]
 pub use super::rootdevs::{DeviceEntry, RootDevs};
 
@@ -342,36 +344,6 @@ pub struct SetAttrs {
     pub ctime: Option<u32>,
 }
 
-/// Filesystem-level capacity stats returned by [`Filesystem::statfs`].
-/// All `u64` so backends with huge counts don't overflow. `name_max`
-/// is the longest filename the FS will accept.
-#[derive(Debug, Clone, Copy)]
-pub struct StatFs {
-    pub block_size: u32,
-    pub blocks: u64,
-    pub blocks_free: u64,
-    pub blocks_avail: u64,
-    pub inodes: u64,
-    pub inodes_free: u64,
-    pub name_max: u32,
-}
-
-impl Default for StatFs {
-    fn default() -> Self {
-        // 4 KiB block, no quota, generous name budget — the same
-        // numbers the kernel hands out for tmpfs in a fresh mount.
-        Self {
-            block_size: 4096,
-            blocks: 0,
-            blocks_free: 0,
-            blocks_avail: 0,
-            inodes: 0,
-            inodes_free: 0,
-            name_max: 255,
-        }
-    }
-}
-
 /// A single extended attribute, returned by [`Filesystem::list_xattrs`].
 #[derive(Debug, Clone)]
 pub struct XattrPair {

src/fs/exfat/volume/mod.rs

@@ -1308,6 +1308,23 @@ impl<D: SectorDriver, const SECTOR: usize> Volume<D, SECTOR> {
         Ok(self.geom.cluster_count - self.used_clusters()?)
     }
 
+    /// Capacity figures in `statfs` shape: clusters as the allocation unit,
+    /// free clusters counted from the allocation bitmap (so the same cost as
+    /// [`Self::free_clusters`]), no inodes, and [`MAX_NAME_LEN`] as
+    /// `name_max`.
+    pub fn statfs(&mut self) -> Result<crate::fs::StatFs, Error<D::Error>> {
+        let free = self.free_clusters()? as u64;
+        Ok(crate::fs::StatFs {
+            block_size: self.geom.cluster_bytes(),
+            blocks: self.geom.cluster_count as u64,
+            blocks_free: free,
+            blocks_avail: free,
+            inodes: 0,
+            inodes_free: 0,
+            name_max: MAX_NAME_LEN as u32,
+        })
+    }
+
     /// Free space in bytes.
     pub fn free_bytes(&mut self) -> Result<u64, Error<D::Error>> {
         Ok(self.free_clusters()? as u64 * self.geom.cluster_bytes() as u64)

src/fs/fat/volume/mod.rs

@@ -1165,6 +1165,22 @@ impl<D: SectorDriver, const SECTOR: usize> Volume<D, SECTOR> {
         Ok(free)
     }
 
+    /// Capacity figures in `statfs` shape: clusters as the allocation unit,
+    /// free clusters from [`Self::free_clusters`] (so the same cost), no
+    /// inodes, and long-name entries' 255-unit limit as `name_max`.
+    pub fn statfs(&mut self) -> Result<crate::fs::StatFs, Error<D::Error>> {
+        let free = self.free_clusters()? as u64;
+        Ok(crate::fs::StatFs {
+            block_size: self.cluster_bytes(),
+            blocks: self.geom.cluster_count as u64,
+            blocks_free: free,
+            blocks_avail: free,
+            inodes: 0,
+            inodes_free: 0,
+            name_max: 255,
+        })
+    }
+
     /// Free space in bytes, from [`Self::free_clusters`].
     pub fn free_bytes(&mut self) -> Result<u64, Error<D::Error>> {
         Ok(self.free_clusters()? as u64 * self.geom.cluster_bytes() as u64)

src/fs/littlefs/volume/mod.rs

@@ -1528,6 +1528,23 @@ impl<D: FlashDriver, const BLOCK: usize, const PROG: usize> Volume<D, BLOCK, PRO
         Ok(total)
     }
 
+    /// Capacity figures in `statfs` shape: erase blocks as the allocation
+    /// unit, free blocks from [`Self::free_blocks`] (so a traversal, or the
+    /// in-use bitmap with `alloc`), no inodes, and the superblock's
+    /// `name_max`.
+    pub fn statfs(&mut self) -> Result<crate::fs::StatFs, Error<D::Error>> {
+        let free = self.free_blocks()? as u64;
+        Ok(crate::fs::StatFs {
+            block_size: self.geom.block_size,
+            blocks: self.geom.block_count as u64,
+            blocks_free: free,
+            blocks_avail: free,
+            inodes: 0,
+            inodes_free: 0,
+            name_max: self.geom.name_max,
+        })
+    }
+
     /// Blocks the filesystem has left.
     pub fn free_blocks(&mut self) -> Result<u32, Error<D::Error>> {
         let used = self.used_blocks()?;

src/fs/mod.rs

@@ -21,6 +21,11 @@ mod api;
 #[cfg(feature = "alloc")]
 pub use api::*;
 
+// Capacity figures, answered by both halves: plain data, so compiled in every
+// configuration.
+mod statfs;
+pub use statfs::StatFs;
+
 #[cfg(all(feature = "alloc", feature = "affs"))]
 pub mod affs;
 #[cfg(all(feature = "alloc", feature = "apfs"))]

src/fs/statfs.rs

@@ -0,0 +1,66 @@
+//! Capacity figures for a mounted filesystem, shaped like POSIX `statfs`.
+//!
+//! It is plain data — no allocation, no device, no feature — so it is
+//! compiled in every configuration and answered by both halves of the
+//! crate: the hosted [`Filesystem::statfs`](crate::fs::Filesystem::statfs)
+//! and, without a heap, [`Volume::statfs`](crate::fs::volume::Volume::statfs)
+//! on the FAT, exFAT and littlefs drivers.
+
+/// Filesystem-level capacity stats.
+///
+/// Counts are in allocation units of `block_size` bytes — clusters on FAT
+/// and exFAT, erase blocks on littlefs, filesystem blocks elsewhere — and
+/// are all `u64` so large volumes do not overflow. `name_max` is the longest
+/// filename the filesystem accepts. A filesystem with no inode table (FAT,
+/// exFAT, littlefs) reports 0 for both inode counts.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct StatFs {
+    /// Bytes in one allocation unit.
+    pub block_size: u32,
+    /// Allocation units holding data, in all.
+    pub blocks: u64,
+    /// Allocation units not in use.
+    pub blocks_free: u64,
+    /// Allocation units an unprivileged writer may use: `blocks_free` on
+    /// filesystems with no reserve.
+    pub blocks_avail: u64,
+    /// Inodes in all, or 0 when the filesystem has no inode table.
+    pub inodes: u64,
+    /// Inodes free.
+    pub inodes_free: u64,
+    /// Longest filename accepted.
+    pub name_max: u32,
+}
+
+impl StatFs {
+    /// Bytes of data the filesystem can hold in all.
+    pub fn total_bytes(&self) -> u64 {
+        self.blocks.saturating_mul(self.block_size as u64)
+    }
+
+    /// Bytes not in use.
+    pub fn free_bytes(&self) -> u64 {
+        self.blocks_free.saturating_mul(self.block_size as u64)
+    }
+
+    /// Bytes an unprivileged writer may still use.
+    pub fn avail_bytes(&self) -> u64 {
+        self.blocks_avail.saturating_mul(self.block_size as u64)
+    }
+}
+
+impl Default for StatFs {
+    fn default() -> Self {
+        // 4 KiB block, no quota, generous name budget — the same
+        // numbers the kernel hands out for tmpfs in a fresh mount.
+        Self {
+            block_size: 4096,
+            blocks: 0,
+            blocks_free: 0,
+            blocks_avail: 0,
+            inodes: 0,
+            inodes_free: 0,
+            name_max: 255,
+        }
+    }
+}

src/fs/volume/any.rs

@@ -625,6 +625,10 @@ impl<D: SectorDriver, const SECTOR: usize, const BLOCK: usize> Volume
         each!(self, |v| Volume::free_bytes(v))
     }
 
+    fn statfs(&mut self) -> Result<crate::fs::StatFs, Self::Error> {
+        each!(self, |v| Volume::statfs(v))
+    }
+
     fn unmount(self) -> Result<D, Self::Error> {
         match self {
             #[cfg(feature = "fat")]

src/fs/volume/exfat.rs

@@ -87,6 +87,9 @@ impl<D: SectorDriver, const S: usize> Volume for Exfat<D, S> {
     fn free_bytes(&mut self) -> Result<u64, Self::Error> {
         Exfat::free_bytes(self)
     }
+    fn statfs(&mut self) -> Result<crate::fs::StatFs, Self::Error> {
+        Exfat::statfs(self)
+    }
     fn unmount(self) -> Result<D, Self::Error> {
         Exfat::unmount(self)
     }