xfs: precalculate inodes and blocks per inode cluster

Source kernel commit: 83dcdb4469e759f984db92616d7885fc14329841

Store the number of inodes and blocks per inode cluster in the mount
data so that we don't have to keep recalculating them.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/db/check.c b/db/check.c
index d9fda4e0a938c68142cab14cc8e8301683395b55..c3dae206f07d29a81fd43a0b54959f789395e86f 100644 (file)
--- a/db/check.c
+++ b/db/check.c
@@ -4396,7 +4396,7 @@ scanfunc_ino(
        int                     ioff;
 
        if (xfs_sb_version_hassparseinodes(&mp->m_sb))
-               blks_per_buf = xfs_icluster_size_fsb(mp);
+               blks_per_buf = mp->m_blocks_per_cluster;
        else
                blks_per_buf = mp->m_ialloc_blks;
        inodes_per_buf = min(XFS_FSB_TO_INO(mp, blks_per_buf),
@@ -4539,7 +4539,7 @@ scanfunc_fino(
        int                     ioff;
 
        if (xfs_sb_version_hassparseinodes(&mp->m_sb))
-               blks_per_buf = xfs_icluster_size_fsb(mp);
+               blks_per_buf = mp->m_blocks_per_cluster;
        else
                blks_per_buf = mp->m_ialloc_blks;
        inodes_per_buf = min(XFS_FSB_TO_INO(mp, blks_per_buf),

diff --git a/db/frag.c b/db/frag.c
index 27b67b1b91b2fc5ad13cca37ee13430c7acf9154..51000d83ab63b033b9445bbf3fc3092e013a1a6f 100644 (file)
--- a/db/frag.c
+++ b/db/frag.c
@@ -474,7 +474,7 @@ scanfunc_ino(
        int                     ioff;
 
        if (xfs_sb_version_hassparseinodes(&mp->m_sb))
-               blks_per_buf = xfs_icluster_size_fsb(mp);
+               blks_per_buf = mp->m_blocks_per_cluster;
        else
                blks_per_buf = mp->m_ialloc_blks;
        inodes_per_buf = min(XFS_FSB_TO_INO(mp, blks_per_buf),

diff --git a/db/metadump.c b/db/metadump.c
index 1d43798194d8a846761f8c9e97167ee7667c5ffd..6ecd5685d8d8346cd9b4f7650f41d50bf7414d0d 100644 (file)
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -2420,7 +2420,7 @@ copy_inode_chunk(
         * we've been passed (large block sizes can hold multiple inode chunks).
         */
        if (xfs_sb_version_hassparseinodes(&mp->m_sb))
-               blks_per_buf = xfs_icluster_size_fsb(mp);
+               blks_per_buf = mp->m_blocks_per_cluster;
        else
                blks_per_buf = mp->m_ialloc_blks;
        inodes_per_buf = min(XFS_FSB_TO_INO(mp, blks_per_buf),

diff --git a/include/xfs_mount.h b/include/xfs_mount.h
index 414f449684267d9851f100b9f4f9e77a24ff56f1..4948fa7024240d58e1cbe0e2dcf54eba4396c464 100644 (file)
--- a/include/xfs_mount.h
+++ b/include/xfs_mount.h
@@ -43,6 +43,8 @@ typedef struct xfs_mount {
        uint8_t                 m_agno_log;     /* log #ag's */
        uint8_t                 m_agino_log;    /* #bits for agino in inum */
        uint                    m_inode_cluster_size;/* min inode buf size */
+       unsigned int            m_inodes_per_cluster;
+       unsigned int            m_blocks_per_cluster;
        uint                    m_blockmask;    /* sb_blocksize-1 */
        uint                    m_blockwsize;   /* sb_blocksize in words */
        uint                    m_blockwmask;   /* blockwsize-1 */

diff --git a/libxfs/init.c b/libxfs/init.c
index cd93658c9592a2700bd26e87f7ab65c113a1b0a6..3302fd00f62e24d211ca611242409dc64fb368cb 100644 (file)
--- a/libxfs/init.c
+++ b/libxfs/init.c
@@ -676,6 +676,8 @@ libxfs_mount(
                if (mp->m_sb.sb_inoalignmt >= XFS_B_TO_FSBT(mp, new_size))
                        mp->m_inode_cluster_size = new_size;
        }
+       mp->m_blocks_per_cluster = xfs_icluster_size_fsb(mp);
+       mp->m_inodes_per_cluster = XFS_FSB_TO_INO(mp, mp->m_blocks_per_cluster);
 
        /*
         * Set whether we're using stripe alignment.

diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
index aa9432c21a6b1cd400d633d02e6b07e1f169c10b..b7c93463bfcecc6127fcaefc81c71a86fae4de13 100644 (file)
--- a/libxfs/xfs_ialloc.c
+++ b/libxfs/xfs_ialloc.c
@@ -282,7 +282,7 @@ xfs_ialloc_inode_init(
 {
        struct xfs_buf          *fbuf;
        struct xfs_dinode       *free;
-       int                     nbufs, blks_per_cluster, inodes_per_cluster;
+       int                     nbufs;
        int                     version;
        int                     i, j;
        xfs_daddr_t             d;
@@ -293,9 +293,7 @@ xfs_ialloc_inode_init(
         * sizes, manipulate the inodes in buffers  which are multiples of the
         * blocks size.
         */
-       blks_per_cluster = xfs_icluster_size_fsb(mp);
-       inodes_per_cluster = XFS_FSB_TO_INO(mp, blks_per_cluster);
-       nbufs = length / blks_per_cluster;
+       nbufs = length / mp->m_blocks_per_cluster;
 
        /*
         * Figure out what version number to use in the inodes we create.  If
@@ -338,9 +336,10 @@ xfs_ialloc_inode_init(
                /*
                 * Get the block.
                 */
-               d = XFS_AGB_TO_DADDR(mp, agno, agbno + (j * blks_per_cluster));
+               d = XFS_AGB_TO_DADDR(mp, agno, agbno +
+                               (j * mp->m_blocks_per_cluster));
                fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
-                                        mp->m_bsize * blks_per_cluster,
+                                        mp->m_bsize * mp->m_blocks_per_cluster,
                                         XBF_UNMAPPED);
                if (!fbuf)
                        return -ENOMEM;
@@ -348,7 +347,7 @@ xfs_ialloc_inode_init(
                /* Initialize the inode buffers and log them appropriately. */
                fbuf->b_ops = &xfs_inode_buf_ops;
                xfs_buf_zero(fbuf, 0, BBTOB(fbuf->b_length));
-               for (i = 0; i < inodes_per_cluster; i++) {
+               for (i = 0; i < mp->m_inodes_per_cluster; i++) {
                        int     ioffset = i << mp->m_sb.sb_inodelog;
                        uint    isize = xfs_dinode_size(version);
 
@@ -2283,7 +2282,6 @@ xfs_imap(
        xfs_agblock_t   agbno;  /* block number of inode in the alloc group */
        xfs_agino_t     agino;  /* inode number within alloc group */
        xfs_agnumber_t  agno;   /* allocation group number */
-       int             blks_per_cluster; /* num blocks per inode cluster */
        xfs_agblock_t   chunk_agbno;    /* first block in inode chunk */
        xfs_agblock_t   cluster_agbno;  /* first block in inode cluster */
        int             error;  /* error code */
@@ -2329,8 +2327,6 @@ xfs_imap(
                return -EINVAL;
        }
 
-       blks_per_cluster = xfs_icluster_size_fsb(mp);
-
        /*
         * For bulkstat and handle lookups, we have an untrusted inode number
         * that we have to verify is valid. We cannot do this just by reading
@@ -2350,7 +2346,7 @@ xfs_imap(
         * If the inode cluster size is the same as the blocksize or
         * smaller we get to the buffer by simple arithmetics.
         */
-       if (blks_per_cluster == 1) {
+       if (mp->m_blocks_per_cluster == 1) {
                offset = XFS_INO_TO_OFFSET(mp, ino);
                ASSERT(offset < mp->m_sb.sb_inopblock);
 
@@ -2379,12 +2375,13 @@ xfs_imap(
 out_map:
        ASSERT(agbno >= chunk_agbno);
        cluster_agbno = chunk_agbno +
-               ((offset_agbno / blks_per_cluster) * blks_per_cluster);
+               ((offset_agbno / mp->m_blocks_per_cluster) *
+                mp->m_blocks_per_cluster);
        offset = ((agbno - cluster_agbno) * mp->m_sb.sb_inopblock) +
                XFS_INO_TO_OFFSET(mp, ino);
 
        imap->im_blkno = XFS_AGB_TO_DADDR(mp, agno, cluster_agbno);
-       imap->im_len = XFS_FSB_TO_BB(mp, blks_per_cluster);
+       imap->im_len = XFS_FSB_TO_BB(mp, mp->m_blocks_per_cluster);
        imap->im_boffset = (unsigned short)(offset << mp->m_sb.sb_inodelog);
 
        /*