[PATCH V12 11/12] famfs: Report device capacity via statfs so df works
From: John Groves
Date: Sun Aug 02 2026 - 22:36:27 EST
From: John Groves <John@xxxxxxxxxx>
Replace simple_statfs(), which reports zero blocks (so df omits the mount),
with famfs_statfs() reporting real capacity and usage.
Add dax_fsdev_size() in drivers/dax/fsdev.c, returning the size fsdev
caches at probe (dev_dax->cached_size - the sum of the device's ranges,
stable while bound), exported. It lives in fsdev.c because cached_size is
set only by the fsdev driver, and famfs only ever holds fsdev-mode daxdevs
(fs_dax_get() enforces DAXDRV_FSDEV_TYPE); famfs.ko therefore depends on
fsdev_dax.ko.
famfs tracks two byte counters under a new stats_sem:
- total_capacity: summed in famfs_install_daxdev() from dax_fsdev_size(),
covering the mount primary and every DAXDEV_OPEN secondary, counted once
per daxdev (on the valid 0->1 transition).
- used_capacity: summed in famfs_file_init_dax() from the fmap's mapped
device bytes (superblock + log + data files).
famfs_statfs() reports total and free (total - used). Free is an
approximation of the userspace allocator's free space (it ignores allocator
gaps and reserved regions), which is adequate for df.
(Side note: I am the maintainer of drivers/dax/fsdev.c)
Signed-off-by: John Groves <john@xxxxxxxxxx>
---
drivers/dax/fsdev.c | 19 +++++++++++++++++
fs/famfs/famfs_file.c | 5 +++++
fs/famfs/famfs_inode.c | 43 ++++++++++++++++++++++++++++++++++++++-
fs/famfs/famfs_internal.h | 8 ++++++++
include/linux/dax.h | 1 +
5 files changed, 75 insertions(+), 1 deletion(-)
diff --git a/drivers/dax/fsdev.c b/drivers/dax/fsdev.c
index 188b2526bee4..a5b4b2d79428 100644
--- a/drivers/dax/fsdev.c
+++ b/drivers/dax/fsdev.c
@@ -104,6 +104,25 @@ static size_t fsdev_dax_recovery_write(struct dax_device *dax_dev, pgoff_t pgoff
return _copy_from_iter_flushcache(addr, bytes, i);
}
+/**
+ * dax_fsdev_size() - total size in bytes of an fsdev dax device
+ * @dax_dev: the dax device (must be bound to this driver)
+ *
+ * Returns the size cached at probe time (sum of all ranges); it cannot change
+ * while the driver is bound. Only valid for fsdev dax devices - callers
+ * ensure that (e.g. fs_dax_get() enforces DAXDRV_FSDEV_TYPE). Returns 0 if the
+ * device is not alive.
+ */
+u64 dax_fsdev_size(struct dax_device *dax_dev)
+{
+ struct dev_dax *dev_dax = dax_get_private(dax_dev);
+
+ if (!dev_dax)
+ return 0;
+ return dev_dax->cached_size;
+}
+EXPORT_SYMBOL_GPL(dax_fsdev_size);
+
static const struct dax_operations dev_dax_ops = {
.direct_access = fsdev_dax_direct_access,
.zero_page_range = fsdev_dax_zero_page_range,
diff --git a/fs/famfs/famfs_file.c b/fs/famfs/famfs_file.c
index abf049b32a4b..5be39d677089 100644
--- a/fs/famfs/famfs_file.c
+++ b/fs/famfs/famfs_file.c
@@ -280,6 +280,11 @@ famfs_file_init_dax(struct file *file, void __user *arg)
}
inode_unlock(inode);
+ /* Account the mapped device bytes for statfs (only on success) */
+ if (!rc) {
+ scoped_guard(rwsem_write, &fsi->stats_sem)
+ fsi->used_capacity += extent_total;
+ }
out:
kvfree(fmap_buf);
if (meta)
diff --git a/fs/famfs/famfs_inode.c b/fs/famfs/famfs_inode.c
index 6cbd7d657fd8..3c0d1094d653 100644
--- a/fs/famfs/famfs_inode.c
+++ b/fs/famfs/famfs_inode.c
@@ -24,6 +24,7 @@
#include <linux/iomap.h>
#include <linux/path.h>
#include <linux/namei.h>
+#include <linux/statfs.h>
#include "famfs_internal.h"
@@ -307,8 +308,37 @@ static void famfs_evict_inode(struct inode *inode)
clear_inode(inode);
}
+/*
+ * famfs_statfs() - report device capacity and consumption so 'df' works.
+ * @total_capacity is the sum of installed daxdev sizes; @used_capacity is the
+ * sum of device bytes mapped by fmaps (superblock + log + data files). Free is
+ * the difference - an approximation of the userspace allocator's free space
+ * (it ignores allocator gaps / reserved regions), which is fine for df.
+ */
+static int famfs_statfs(struct dentry *dentry, struct kstatfs *buf)
+{
+ struct famfs_fs_info *fsi = dentry->d_sb->s_fs_info;
+ u64 total, used, free;
+
+ scoped_guard(rwsem_read, &fsi->stats_sem) {
+ total = fsi->total_capacity;
+ used = fsi->used_capacity;
+ }
+ free = total > used ? total - used : 0;
+
+ buf->f_type = FAMFS_SUPER_MAGIC;
+ buf->f_bsize = PAGE_SIZE;
+ buf->f_frsize = PAGE_SIZE;
+ buf->f_blocks = total >> PAGE_SHIFT;
+ buf->f_bfree = free >> PAGE_SHIFT;
+ buf->f_bavail = free >> PAGE_SHIFT; /* no root reservation */
+ buf->f_namelen = NAME_MAX;
+ buf->f_fsid = u64_to_fsid(huge_encode_dev(dentry->d_sb->s_dev));
+ return 0;
+}
+
static const struct super_operations famfs_super_ops = {
- .statfs = simple_statfs,
+ .statfs = famfs_statfs,
.drop_inode = inode_just_drop,
.show_options = famfs_show_options,
.evict_inode = famfs_evict_inode,
@@ -399,6 +429,7 @@ int famfs_install_daxdev(
const char *name)
{
struct famfs_daxdev *daxdev;
+ struct dax_device *devp = NULL;
int rc = 0;
if (index >= fsi->dax_devlist->nslots) {
@@ -462,6 +493,15 @@ int famfs_install_daxdev(
wmb(); /* All other fields must be visible before valid */
daxdev->valid = 1;
+ devp = daxdev->devp;
+ }
+
+ /* Freshly installed: add its capacity to the statfs accounting */
+ if (devp) {
+ u64 sz = dax_fsdev_size(devp);
+
+ scoped_guard(rwsem_write, &fsi->stats_sem)
+ fsi->total_capacity += sz;
}
return 0;
@@ -717,6 +757,7 @@ static int famfs_init_fs_context(struct fs_context *fc)
return -ENOMEM;
init_rwsem(&fsi->devlist_sem);
+ init_rwsem(&fsi->stats_sem);
atomic64_set(&fsi->opts, FAMFS_OPT_DEFAULT);
fsi->mount_opts.mode = FAMFS_DEFAULT_MODE;
fc->s_fs_info = fsi;
diff --git a/fs/famfs/famfs_internal.h b/fs/famfs/famfs_internal.h
index 26873162b4a0..0bf50774fa82 100644
--- a/fs/famfs/famfs_internal.h
+++ b/fs/famfs/famfs_internal.h
@@ -123,6 +123,11 @@ struct famfs_dax_devlist {
* point, or if other "shutdown" conditions exist
* @dax_devlist: Table of backing daxdevs (slot 0 is the mount primary)
* @devlist_sem: Serializes installs into, and teardown of, @dax_devlist
+ * @stats_sem: Protects the statfs accounting counters below
+ * @total_capacity: Sum of installed daxdev sizes, in bytes (grows as daxdevs
+ * are added)
+ * @used_capacity: Sum of installed fmap sizes, in bytes (grows as MAP_CREATE
+ * attaches fmaps; this is device bytes consumed, not file size)
*/
struct famfs_fs_info {
struct famfs_mount_opts mount_opts;
@@ -130,6 +135,9 @@ struct famfs_fs_info {
bool deverror;
struct famfs_dax_devlist *dax_devlist;
struct rw_semaphore devlist_sem;
+ struct rw_semaphore stats_sem;
+ u64 total_capacity;
+ u64 used_capacity;
};
/*
diff --git a/include/linux/dax.h b/include/linux/dax.h
index 29113eb95e72..c25ef499d04f 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -256,6 +256,7 @@ static inline void dax_break_layout_final(struct inode *inode)
bool dax_alive(struct dax_device *dax_dev);
void *dax_get_private(struct dax_device *dax_dev);
+u64 dax_fsdev_size(struct dax_device *dax_dev);
int dax_set_ops(struct dax_device *dax_dev, const struct dax_operations *ops);
long dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff, long nr_pages,
enum dax_access_mode mode, void **kaddr, unsigned long *pfn);
--
2.53.0