On Mon, Aug 03, 2026 at 02:30:07AM +0000, John Groves wrote:
> From: John Groves <[email protected]>
>
> 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 <[email protected]>
> ---
> 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;
Can dax devices change size the same way block devices can?
Though for statfs that hardly matters; a bdev shrinkage rarely causes
b_avail to be updated even if the filesystem starts barfing IO errors
due to invalid LBA range.
The code in here looks good to me otherwise.
--D
> }
>
> 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
>
>
>
