xfs: remove unused flags arg from getsb interfaces

[linux-block.git] / fs / xfs / xfs_mount.c

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 6b2bfe81dc51be79b5b3d736dc3b8f0f459f09ec..4e2c63649cab04cb9ba54a85ef1ac2b656c1aa56 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -429,30 +429,6 @@ xfs_update_alignment(xfs_mount_t *mp)
        return 0;
 }
 
-/*
- * Set the maximum inode count for this filesystem
- */
-STATIC void
-xfs_set_maxicount(xfs_mount_t *mp)
-{
-       xfs_sb_t        *sbp = &(mp->m_sb);
-       uint64_t        icount;
-
-       if (sbp->sb_imax_pct) {
-               /*
-                * Make sure the maximum inode count is a multiple
-                * of the units we allocate inodes in.
-                */
-               icount = sbp->sb_dblocks * sbp->sb_imax_pct;
-               do_div(icount, 100);
-               do_div(icount, mp->m_ialloc_blks);
-               mp->m_maxicount = (icount * mp->m_ialloc_blks)  <<
-                                  sbp->sb_inopblog;
-       } else {
-               mp->m_maxicount = 0;
-       }
-}
-
 /*
  * Set the default minimum read and write sizes unless
  * already specified in a mount option.
@@ -509,29 +485,6 @@ xfs_set_low_space_thresholds(
        }
 }
 
-
-/*
- * Set whether we're using inode alignment.
- */
-STATIC void
-xfs_set_inoalignment(xfs_mount_t *mp)
-{
-       if (xfs_sb_version_hasalign(&mp->m_sb) &&
-               mp->m_sb.sb_inoalignmt >= xfs_icluster_size_fsb(mp))
-               mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
-       else
-               mp->m_inoalign_mask = 0;
-       /*
-        * If we are using stripe alignment, check whether
-        * the stripe unit is a multiple of the inode alignment
-        */
-       if (mp->m_dalign && mp->m_inoalign_mask &&
-           !(mp->m_dalign & mp->m_inoalign_mask))
-               mp->m_sinoalign = mp->m_dalign;
-       else
-               mp->m_sinoalign = 0;
-}
-
 /*
  * Check that the data (and log if separate) is an ok size.
  */
@@ -683,6 +636,7 @@ xfs_mountfs(
 {
        struct xfs_sb           *sbp = &(mp->m_sb);
        struct xfs_inode        *rip;
+       struct xfs_ino_geometry *igeo = M_IGEO(mp);
        uint64_t                resblks;
        uint                    quotamount = 0;
        uint                    quotaflags = 0;
@@ -749,12 +703,10 @@ xfs_mountfs(
        xfs_alloc_compute_maxlevels(mp);
        xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
        xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
-       xfs_ialloc_compute_maxlevels(mp);
+       xfs_ialloc_setup_geometry(mp);
        xfs_rmapbt_compute_maxlevels(mp);
        xfs_refcountbt_compute_maxlevels(mp);
 
-       xfs_set_maxicount(mp);
-
        /* enable fail_at_unmount as default */
        mp->m_fail_unmount = true;
 
@@ -787,29 +739,6 @@ xfs_mountfs(
        /* set the low space thresholds for dynamic preallocation */
        xfs_set_low_space_thresholds(mp);
 
-       /*
-        * Set the inode cluster size.
-        * This may still be overridden by the file system
-        * block size if it is larger than the chosen cluster size.
-        *
-        * For v5 filesystems, scale the cluster size with the inode size to
-        * keep a constant ratio of inode per cluster buffer, but only if mkfs
-        * has set the inode alignment value appropriately for larger cluster
-        * sizes.
-        */
-       mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
-       if (xfs_sb_version_hascrc(&mp->m_sb)) {
-               int     new_size = mp->m_inode_cluster_size;
-
-               new_size *= mp->m_sb.sb_inodesize / XFS_DINODE_MIN_SIZE;
-               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);
-       mp->m_cluster_align = xfs_ialloc_cluster_alignment(mp);
-       mp->m_cluster_align_inodes = XFS_FSB_TO_INO(mp, mp->m_cluster_align);
-
        /*
         * If enabled, sparse inode chunk alignment is expected to match the
         * cluster size. Full inode chunk alignment must match the chunk size,
@@ -817,20 +746,15 @@ xfs_mountfs(
         */
        if (xfs_sb_version_hassparseinodes(&mp->m_sb) &&
            mp->m_sb.sb_spino_align !=
-                       XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) {
+                       XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)) {
                xfs_warn(mp,
        "Sparse inode block alignment (%u) must match cluster size (%llu).",
                         mp->m_sb.sb_spino_align,
-                        XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size));
+                        XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw));
                error = -EINVAL;
                goto out_remove_uuid;
        }
 
-       /*
-        * Set inode alignment fields
-        */
-       xfs_set_inoalignment(mp);
-
        /*
         * Check that the data (and log if separate) is an ok size.
         */
@@ -1385,24 +1309,14 @@ xfs_mod_frextents(
  * xfs_getsb() is called to obtain the buffer for the superblock.
  * The buffer is returned locked and read in from disk.
  * The buffer should be released with a call to xfs_brelse().
- *
- * If the flags parameter is BUF_TRYLOCK, then we'll only return
- * the superblock buffer if it can be locked without sleeping.
- * If it can't then we'll return NULL.
  */
 struct xfs_buf *
 xfs_getsb(
-       struct xfs_mount        *mp,
-       int                     flags)
+       struct xfs_mount        *mp)
 {
        struct xfs_buf          *bp = mp->m_sb_bp;
 
-       if (!xfs_buf_trylock(bp)) {
-               if (flags & XBF_TRYLOCK)
-                       return NULL;
-               xfs_buf_lock(bp);
-       }
-
+       xfs_buf_lock(bp);
        xfs_buf_hold(bp);
        ASSERT(bp->b_flags & XBF_DONE);
        return bp;