xfs: refactor xfs_fs_statfs

Split out helpers for data, rt data and inode related information, and
assigning f_bavail once instead of in three places.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Carlos Maiolino <cem@kernel.org>

diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index db5b8afd9d1b970fb6fa27a8aa088ff9cb0b556e..37f1230e75846af05ae2282a90cfada3100cd5d1 100644 (file)
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -40,7 +40,6 @@ xfs_fill_statvfs_from_dquot(
 
                statp->f_blocks = min(statp->f_blocks, limit);
                statp->f_bfree = min(statp->f_bfree, remaining);
-               statp->f_bavail = min(statp->f_bavail, remaining);
        }
 
        limit = dqp->q_ino.softlimit ?

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 20cc00b992a6ef974359bf1b8b630860dadfdb7d..809ac6d1813ca3279d970e9b0c7e443377ca3aa9 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -819,81 +819,105 @@ xfs_fs_sync_fs(
        return 0;
 }
 
-STATIC int
-xfs_fs_statfs(
-       struct dentry           *dentry,
-       struct kstatfs          *statp)
+static xfs_extlen_t
+xfs_internal_log_size(
+       struct xfs_mount        *mp)
 {
-       struct xfs_mount        *mp = XFS_M(dentry->d_sb);
-       xfs_sb_t                *sbp = &mp->m_sb;
-       struct xfs_inode        *ip = XFS_I(d_inode(dentry));
-       uint64_t                fakeinos, id;
-       uint64_t                icount;
-       uint64_t                ifree;
-       uint64_t                fdblocks;
-       xfs_extlen_t            lsize;
-       int64_t                 ffree;
-
-       /*
-        * Expedite background inodegc but don't wait. We do not want to block
-        * here waiting hours for a billion extent file to be truncated.
-        */
-       xfs_inodegc_push(mp);
-
-       statp->f_type = XFS_SUPER_MAGIC;
-       statp->f_namelen = MAXNAMELEN - 1;
-
-       id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
-       statp->f_fsid = u64_to_fsid(id);
+       if (!mp->m_sb.sb_logstart)
+               return 0;
+       return mp->m_sb.sb_logblocks;
+}
 
-       icount = percpu_counter_sum(&mp->m_icount);
-       ifree = percpu_counter_sum(&mp->m_ifree);
-       fdblocks = percpu_counter_sum(&mp->m_fdblocks);
+static void
+xfs_statfs_data(
+       struct xfs_mount        *mp,
+       struct kstatfs          *st)
+{
+       int64_t                 fdblocks =
+               percpu_counter_sum(&mp->m_fdblocks);
 
-       statp->f_bsize = sbp->sb_blocksize;
-       lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
+       /* make sure st->f_bfree does not underflow */
+       st->f_bfree = max(0LL, fdblocks - xfs_fdblocks_unavailable(mp));
        /*
         * sb_dblocks can change during growfs, but nothing cares about reporting
         * the old or new value during growfs.
         */
-       statp->f_blocks = sbp->sb_dblocks - lsize;
+       st->f_blocks = mp->m_sb.sb_dblocks - xfs_internal_log_size(mp);
+}
+
+/*
+ * When stat(v)fs is called on a file with the realtime bit set or a directory
+ * with the rtinherit bit, report freespace information for the RT device
+ * instead of the main data device.
+ */
+static void
+xfs_statfs_rt(
+       struct xfs_mount        *mp,
+       struct kstatfs          *st)
+{
+       st->f_bfree = xfs_rtbxlen_to_blen(mp,
+                       percpu_counter_sum_positive(&mp->m_frextents));
+       st->f_blocks = mp->m_sb.sb_rblocks;
+}
 
-       /* make sure statp->f_bfree does not underflow */
-       statp->f_bfree = max_t(int64_t, 0,
-                               fdblocks - xfs_fdblocks_unavailable(mp));
-       statp->f_bavail = statp->f_bfree;
+static void
+xfs_statfs_inodes(
+       struct xfs_mount        *mp,
+       struct kstatfs          *st)
+{
+       uint64_t                icount = percpu_counter_sum(&mp->m_icount);
+       uint64_t                ifree = percpu_counter_sum(&mp->m_ifree);
+       uint64_t                fakeinos = XFS_FSB_TO_INO(mp, st->f_bfree);
 
-       fakeinos = XFS_FSB_TO_INO(mp, statp->f_bfree);
-       statp->f_files = min(icount + fakeinos, (uint64_t)XFS_MAXINUMBER);
+       st->f_files = min(icount + fakeinos, (uint64_t)XFS_MAXINUMBER);
        if (M_IGEO(mp)->maxicount)
-               statp->f_files = min_t(typeof(statp->f_files),
-                                       statp->f_files,
+               st->f_files = min_t(typeof(st->f_files), st->f_files,
                                        M_IGEO(mp)->maxicount);
 
        /* If sb_icount overshot maxicount, report actual allocation */
-       statp->f_files = max_t(typeof(statp->f_files),
-                                       statp->f_files,
-                                       sbp->sb_icount);
+       st->f_files = max_t(typeof(st->f_files), st->f_files,
+                       mp->m_sb.sb_icount);
 
-       /* make sure statp->f_ffree does not underflow */
-       ffree = statp->f_files - (icount - ifree);
-       statp->f_ffree = max_t(int64_t, ffree, 0);
+       /* Make sure st->f_ffree does not underflow */
+       st->f_ffree = max_t(int64_t, 0, st->f_files - (icount - ifree));
+}
 
-       if (XFS_IS_REALTIME_MOUNT(mp) &&
-           (ip->i_diflags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME))) {
-               s64     freertx;
+STATIC int
+xfs_fs_statfs(
+       struct dentry           *dentry,
+       struct kstatfs          *st)
+{
+       struct xfs_mount        *mp = XFS_M(dentry->d_sb);
+       struct xfs_inode        *ip = XFS_I(d_inode(dentry));
 
-               statp->f_blocks = sbp->sb_rblocks;
-               freertx = percpu_counter_sum_positive(&mp->m_frextents);
-               statp->f_bavail = statp->f_bfree =
-                       xfs_rtbxlen_to_blen(mp, freertx);
-       }
+       /*
+        * Expedite background inodegc but don't wait. We do not want to block
+        * here waiting hours for a billion extent file to be truncated.
+        */
+       xfs_inodegc_push(mp);
+
+       st->f_type = XFS_SUPER_MAGIC;
+       st->f_namelen = MAXNAMELEN - 1;
+       st->f_bsize = mp->m_sb.sb_blocksize;
+       st->f_fsid = u64_to_fsid(huge_encode_dev(mp->m_ddev_targp->bt_dev));
+
+       xfs_statfs_data(mp, st);
+       xfs_statfs_inodes(mp, st);
+
+       if (XFS_IS_REALTIME_MOUNT(mp) &&
+           (ip->i_diflags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME)))
+               xfs_statfs_rt(mp, st);
 
        if ((ip->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
            ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
                              (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
-               xfs_qm_statvfs(ip, statp);
+               xfs_qm_statvfs(ip, st);
 
+       /*
+        * XFS does not distinguish between blocks available to privileged and
+        * unprivileged users.
+        */
+       st->f_bavail = st->f_bfree;
        return 0;
 }