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; } 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
