xfs: replace m_rsumsize with m_rsumblocks

Track the RT summary file size in blocks, just like the RT bitmap
file.  While we have users of both units, blocks are used slightly
more often and this matches the bitmap file for consistency.

Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/fs/xfs/libxfs/xfs_rtbitmap.c b/fs/xfs/libxfs/xfs_rtbitmap.c
index f3167a776bbb424295b7db8933772c834504accc..77d0d9dac1fa431585b1ee8a8c63c7aab129a8c7 100644 (file)
--- a/fs/xfs/libxfs/xfs_rtbitmap.c
+++ b/fs/xfs/libxfs/xfs_rtbitmap.c
@@ -162,7 +162,7 @@ xfs_rtsummary_read_buf(
 {
        struct xfs_mount                *mp = args->mp;
 
-       if (XFS_IS_CORRUPT(mp, block >= XFS_B_TO_FSB(mp, mp->m_rsumsize))) {
+       if (XFS_IS_CORRUPT(mp, block >= mp->m_rsumblocks)) {
                xfs_rt_mark_sick(args->mp, XFS_SICK_RT_SUMMARY);
                return -EFSCORRUPTED;
        }

diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
index 3dc8f785bf2947dec439cd5c9009772ab3ebef24..083e6a59e5e686669be99ca12e2146cc97d01040 100644 (file)
--- a/fs/xfs/libxfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
@@ -918,7 +918,7 @@ xfs_calc_growrtfree_reservation(
        return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
                xfs_calc_inode_res(mp, 2) +
                xfs_calc_buf_res(1, mp->m_sb.sb_blocksize) +
-               xfs_calc_buf_res(1, mp->m_rsumsize);
+               xfs_calc_buf_res(1, XFS_FSB_TO_B(mp, mp->m_rsumblocks));
 }
 
 /*

diff --git a/fs/xfs/scrub/rtsummary.c b/fs/xfs/scrub/rtsummary.c
index 3fee603f52441081f70e4a33b48567c05f7f0c09..7c7366c98338b03437053568d7dcba44fc3645ed 100644 (file)
--- a/fs/xfs/scrub/rtsummary.c
+++ b/fs/xfs/scrub/rtsummary.c
@@ -63,7 +63,8 @@ xchk_setup_rtsummary(
         * us to avoid pinning kernel memory for this purpose.
         */
        descr = xchk_xfile_descr(sc, "realtime summary file");
-       error = xfile_create(descr, mp->m_rsumsize, &sc->xfile);
+       error = xfile_create(descr, XFS_FSB_TO_B(mp, mp->m_rsumblocks),
+                       &sc->xfile);
        kfree(descr);
        if (error)
                return error;
@@ -95,16 +96,14 @@ xchk_setup_rtsummary(
         * volume.  Hence it is safe to compute and check the geometry values.
         */
        if (mp->m_sb.sb_rblocks) {
-               xfs_filblks_t   rsumblocks;
                int             rextslog;
 
                rts->rextents = xfs_rtb_to_rtx(mp, mp->m_sb.sb_rblocks);
                rextslog = xfs_compute_rextslog(rts->rextents);
                rts->rsumlevels = rextslog + 1;
                rts->rbmblocks = xfs_rtbitmap_blockcount(mp, rts->rextents);
-               rsumblocks = xfs_rtsummary_blockcount(mp, rts->rsumlevels,
+               rts->rsumblocks = xfs_rtsummary_blockcount(mp, rts->rsumlevels,
                                rts->rbmblocks);
-               rts->rsumsize = XFS_FSB_TO_B(mp, rsumblocks);
        }
        return 0;
 }
@@ -316,7 +315,7 @@ xchk_rtsummary(
        }
 
        /* Is m_rsumsize correct? */
-       if (mp->m_rsumsize != rts->rsumsize) {
+       if (mp->m_rsumblocks != rts->rsumblocks) {
                xchk_ino_set_corrupt(sc, mp->m_rsumip->i_ino);
                goto out_rbm;
        }
@@ -332,7 +331,7 @@ xchk_rtsummary(
         * growfsrt expands the summary file before updating sb_rextents, so
         * the file can be larger than rsumsize.
         */
-       if (mp->m_rsumip->i_disk_size < rts->rsumsize) {
+       if (mp->m_rsumip->i_disk_size < XFS_FSB_TO_B(mp, rts->rsumblocks)) {
                xchk_ino_set_corrupt(sc, mp->m_rsumip->i_ino);
                goto out_rbm;
        }

diff --git a/fs/xfs/scrub/rtsummary.h b/fs/xfs/scrub/rtsummary.h
index e1d50304d8d481ebd902ead09a67fa4520c27a9a..e44b04cb6e2d5e37479eb89b8991935715202e74 100644 (file)
--- a/fs/xfs/scrub/rtsummary.h
+++ b/fs/xfs/scrub/rtsummary.h
@@ -14,7 +14,7 @@ struct xchk_rtsummary {
 
        uint64_t                rextents;
        uint64_t                rbmblocks;
-       uint64_t                rsumsize;
+       xfs_filblks_t           rsumblocks;
        unsigned int            rsumlevels;
        unsigned int            resblks;
 

diff --git a/fs/xfs/scrub/rtsummary_repair.c b/fs/xfs/scrub/rtsummary_repair.c
index d9e971c4c79fb267129002644de5310e94eb825a..7deeb948cb7027665bc1d01cc4306a7408f346b1 100644 (file)
--- a/fs/xfs/scrub/rtsummary_repair.c
+++ b/fs/xfs/scrub/rtsummary_repair.c
@@ -56,7 +56,7 @@ xrep_setup_rtsummary(
         * transaction (which we cannot drop because we cannot drop the
         * rtsummary ILOCK) and cannot ask for more reservation.
         */
-       blocks = XFS_B_TO_FSB(mp, mp->m_rsumsize);
+       blocks = mp->m_rsumblocks;
        blocks += xfs_bmbt_calc_size(mp, blocks) * 2;
        if (blocks > UINT_MAX)
                return -EOPNOTSUPP;
@@ -100,7 +100,6 @@ xrep_rtsummary(
 {
        struct xchk_rtsummary   *rts = sc->buf;
        struct xfs_mount        *mp = sc->mp;
-       xfs_filblks_t           rsumblocks;
        int                     error;
 
        /* We require the rmapbt to rebuild anything. */
@@ -131,10 +130,9 @@ xrep_rtsummary(
        }
 
        /* Make sure we have space allocated for the entire summary file. */
-       rsumblocks = XFS_B_TO_FSB(mp, rts->rsumsize);
        xfs_trans_ijoin(sc->tp, sc->ip, 0);
        xfs_trans_ijoin(sc->tp, sc->tempip, 0);
-       error = xrep_tempfile_prealloc(sc, 0, rsumblocks);
+       error = xrep_tempfile_prealloc(sc, 0, rts->rsumblocks);
        if (error)
                return error;
 
@@ -143,11 +141,11 @@ xrep_rtsummary(
                return error;
 
        /* Copy the rtsummary file that we generated. */
-       error = xrep_tempfile_copyin(sc, 0, rsumblocks,
+       error = xrep_tempfile_copyin(sc, 0, rts->rsumblocks,
                        xrep_rtsummary_prep_buf, rts);
        if (error)
                return error;
-       error = xrep_tempfile_set_isize(sc, rts->rsumsize);
+       error = xrep_tempfile_set_isize(sc, XFS_FSB_TO_B(mp, rts->rsumblocks));
        if (error)
                return error;
 
@@ -168,7 +166,7 @@ xrep_rtsummary(
                memset(mp->m_rsum_cache, 0xFF, mp->m_sb.sb_rbmblocks);
 
        mp->m_rsumlevels = rts->rsumlevels;
-       mp->m_rsumsize = rts->rsumsize;
+       mp->m_rsumblocks = rts->rsumblocks;
 
        /* Free the old rtsummary blocks if they're not in use. */
        return xrep_reap_ifork(sc, sc->tempip, XFS_DATA_FORK);

diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 6251ebced3062237d4940064983aaaf2229436f5..9e883d2159fd98ecc6bfab8a105af39091a2d3f6 100644 (file)
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -148,7 +148,7 @@ typedef struct xfs_mount {
        int                     m_logbufs;      /* number of log buffers */
        int                     m_logbsize;     /* size of each log buffer */
        uint                    m_rsumlevels;   /* rt summary levels */
-       uint                    m_rsumsize;     /* size of rt summary, bytes */
+       xfs_filblks_t           m_rsumblocks;   /* size of rt summary, FSBs */
        int                     m_fixedfsid[2]; /* unchanged for life of FS */
        uint                    m_qflags;       /* quota status flags */
        uint64_t                m_features;     /* active filesystem features */

diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index c53f4d0dfac365b0ca851ddc3c336e3a65e43014..2f2b7f386d8bc13e0478a4a782a35578debbb785 100644 (file)
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -703,9 +703,8 @@ xfs_growfs_rt_bmblock(
        nmp->m_sb.sb_rextents = xfs_rtb_to_rtx(nmp, nmp->m_sb.sb_rblocks);
        nmp->m_sb.sb_rextslog = xfs_compute_rextslog(nmp->m_sb.sb_rextents);
        nmp->m_rsumlevels = nmp->m_sb.sb_rextslog + 1;
-       nmp->m_rsumsize = XFS_FSB_TO_B(mp,
-               xfs_rtsummary_blockcount(mp, nmp->m_rsumlevels,
-                       nmp->m_sb.sb_rbmblocks));
+       nmp->m_rsumblocks = xfs_rtsummary_blockcount(mp, nmp->m_rsumlevels,
+                       nmp->m_sb.sb_rbmblocks);
 
        /*
         * Recompute the growfsrt reservation from the new rsumsize, so that the
@@ -735,7 +734,7 @@ xfs_growfs_rt_bmblock(
         * so that inode inactivation won't punch what it thinks are "posteof"
         * blocks.
         */
-       rsumip->i_disk_size = nmp->m_rsumsize;
+       rsumip->i_disk_size = nmp->m_rsumblocks * nmp->m_sb.sb_blocksize;
        i_size_write(VFS_I(rsumip), rsumip->i_disk_size);
        xfs_trans_log_inode(args.tp, rsumip, XFS_ILOG_CORE);
 
@@ -787,7 +786,7 @@ xfs_growfs_rt_bmblock(
         * Update the calculated values in the real mount structure.
         */
        mp->m_rsumlevels = nmp->m_rsumlevels;
-       mp->m_rsumsize = nmp->m_rsumsize;
+       mp->m_rsumblocks = nmp->m_rsumblocks;
        xfs_mount_sb_set_rextsize(mp, &mp->m_sb);
 
        /*
@@ -973,7 +972,6 @@ xfs_rtmount_init(
        struct xfs_buf          *bp;    /* buffer for last block of subvolume */
        struct xfs_sb           *sbp;   /* filesystem superblock copy in mount */
        xfs_daddr_t             d;      /* address of last block of subvolume */
-       unsigned int            rsumblocks;
        int                     error;
 
        sbp = &mp->m_sb;
@@ -985,9 +983,8 @@ xfs_rtmount_init(
                return -ENODEV;
        }
        mp->m_rsumlevels = sbp->sb_rextslog + 1;
-       rsumblocks = xfs_rtsummary_blockcount(mp, mp->m_rsumlevels,
+       mp->m_rsumblocks = xfs_rtsummary_blockcount(mp, mp->m_rsumlevels,
                        mp->m_sb.sb_rbmblocks);
-       mp->m_rsumsize = XFS_FSB_TO_B(mp, rsumblocks);
        mp->m_rbmip = mp->m_rsumip = NULL;
        /*
         * Check that the realtime section is an ok size.