27 files changed, 48 insertions, 76 deletions

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index 39387bdd225d..4bcc095fe44a 100644
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -1947,7 +1947,7 @@ void
 xfs_alloc_compute_maxlevels(
         xfs_mount_t     *mp)    /* file system mount structure */
 {
-        mp->m_ag_maxlevels = xfs_btree_compute_maxlevels(mp, mp->m_alloc_mnr,
+        mp->m_ag_maxlevels = xfs_btree_compute_maxlevels(mp->m_alloc_mnr,
                         (mp->m_sb.sb_agblocks + 1) / 2);
 }
 
@@ -1959,7 +1959,6 @@ xfs_alloc_compute_maxlevels(
  */
 xfs_extlen_t
 xfs_alloc_longest_free_extent(
-        struct xfs_mount        *mp,
         struct xfs_perag        *pag,
         xfs_extlen_t            need,
         xfs_extlen_t            reserved)
@@ -2038,8 +2037,7 @@ xfs_alloc_space_available(
 
         /* do we have enough contiguous free space for the allocation? */
         alloc_len = args->minlen + (args->alignment - 1) + args->minalignslop;
-        longest = xfs_alloc_longest_free_extent(args->mp, pag, min_free,
-                        reservation);
+        longest = xfs_alloc_longest_free_extent(pag, min_free, reservation);
         if (longest < alloc_len)
                 return false;
 
diff --git a/fs/xfs/libxfs/xfs_alloc.h b/fs/xfs/libxfs/xfs_alloc.h
index a311a2414a6b..cbf789ea5a4e 100644
--- a/fs/xfs/libxfs/xfs_alloc.h
+++ b/fs/xfs/libxfs/xfs_alloc.h
@@ -116,9 +116,8 @@ xfs_alloc_allow_busy_reuse(int datatype)
 unsigned int xfs_alloc_set_aside(struct xfs_mount *mp);
 unsigned int xfs_alloc_ag_max_usable(struct xfs_mount *mp);
 
-xfs_extlen_t xfs_alloc_longest_free_extent(struct xfs_mount *mp,
-                struct xfs_perag *pag, xfs_extlen_t need,
-                xfs_extlen_t reserved);
+xfs_extlen_t xfs_alloc_longest_free_extent(struct xfs_perag *pag,
+                xfs_extlen_t need, xfs_extlen_t reserved);
 unsigned int xfs_alloc_min_freelist(struct xfs_mount *mp,
                 struct xfs_perag *pag);
 
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 3b03d886df66..6a7c2f03ea11 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -3225,7 +3225,7 @@ xfs_bmap_longest_free_extent(
                 }
         }
 
-        longest = xfs_alloc_longest_free_extent(mp, pag,
+        longest = xfs_alloc_longest_free_extent(pag,
                                 xfs_alloc_min_freelist(mp, pag),
                                 xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));
         if (*blen < longest)
@@ -5667,7 +5667,6 @@ xfs_bmap_collapse_extents(
         xfs_fileoff_t           *next_fsb,
         xfs_fileoff_t           offset_shift_fsb,
         bool                    *done,
-        xfs_fileoff_t           stop_fsb,
         xfs_fsblock_t           *firstblock,
         struct xfs_defer_ops    *dfops)
 {
diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
index f3be6416260b..2b766b37096d 100644
--- a/fs/xfs/libxfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
@@ -228,7 +228,7 @@ void	xfs_bmap_del_extent_cow(struct xfs_inode *ip,
 uint    xfs_default_attroffset(struct xfs_inode *ip);
 int     xfs_bmap_collapse_extents(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb,
-                bool *done, xfs_fileoff_t stop_fsb, xfs_fsblock_t *firstblock,
+                bool *done, xfs_fsblock_t *firstblock,
                 struct xfs_defer_ops *dfops);
 int     xfs_bmap_insert_extents(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb,
diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index edc0193358a5..ac7d66427e42 100644
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -4531,7 +4531,6 @@ xfs_btree_sblock_verify(
  */
 uint
 xfs_btree_compute_maxlevels(
-        struct xfs_mount        *mp,
         uint                    *limits,
         unsigned long           len)
 {
@@ -4839,7 +4838,6 @@ xfs_btree_query_all(
  */
 xfs_extlen_t
 xfs_btree_calc_size(
-        struct xfs_mount        *mp,
         uint                    *limits,
         unsigned long long      len)
 {
diff --git a/fs/xfs/libxfs/xfs_btree.h b/fs/xfs/libxfs/xfs_btree.h
index 58e30c0975c3..9227159a751e 100644
--- a/fs/xfs/libxfs/xfs_btree.h
+++ b/fs/xfs/libxfs/xfs_btree.h
@@ -481,10 +481,8 @@ xfs_failaddr_t xfs_btree_lblock_v5hdr_verify(struct xfs_buf *bp,
 xfs_failaddr_t xfs_btree_lblock_verify(struct xfs_buf *bp,
                 unsigned int max_recs);
 
-uint xfs_btree_compute_maxlevels(struct xfs_mount *mp, uint *limits,
-                                 unsigned long len);
-xfs_extlen_t xfs_btree_calc_size(struct xfs_mount *mp, uint *limits,
-                unsigned long long len);
+uint xfs_btree_compute_maxlevels(uint *limits, unsigned long len);
+xfs_extlen_t xfs_btree_calc_size(uint *limits, unsigned long long len);
 
 /* return codes */
 #define XFS_BTREE_QUERY_RANGE_CONTINUE  0       /* keep iterating */
diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 0e2cf5f0be1f..de627fa19168 100644
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -2406,7 +2406,7 @@ xfs_ialloc_compute_maxlevels(
         uint            inodes;
 
         inodes = (1LL << XFS_INO_AGINO_BITS(mp)) >> XFS_INODES_PER_CHUNK_LOG;
-        mp->m_in_maxlevels = xfs_btree_compute_maxlevels(mp, mp->m_inobt_mnr,
+        mp->m_in_maxlevels = xfs_btree_compute_maxlevels(mp->m_inobt_mnr,
                                                          inodes);
 }
 
diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index a2dd7f4a2719..367e9a0726e6 100644
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -556,7 +556,7 @@ xfs_inobt_max_size(
         if (mp->m_inobt_mxr[0] == 0)
                 return 0;
 
-        return xfs_btree_calc_size(mp, mp->m_inobt_mnr,
+        return xfs_btree_calc_size(mp->m_inobt_mnr,
                 (uint64_t)mp->m_sb.sb_agblocks * mp->m_sb.sb_inopblock /
                                 XFS_INODES_PER_CHUNK);
 }
diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c
index bee68c23d612..560e28473024 100644
--- a/fs/xfs/libxfs/xfs_refcount.c
+++ b/fs/xfs/libxfs/xfs_refcount.c
@@ -351,7 +351,6 @@ xfs_refcount_merge_center_extents(
         struct xfs_refcount_irec        *center,
         struct xfs_refcount_irec        *right,
         unsigned long long              extlen,
-        xfs_agblock_t                   *agbno,
         xfs_extlen_t                    *aglen)
 {
         int                             error;
@@ -471,7 +470,6 @@ xfs_refcount_merge_right_extent(
         struct xfs_btree_cur            *cur,
         struct xfs_refcount_irec        *right,
         struct xfs_refcount_irec        *cright,
-        xfs_agblock_t                   *agbno,
         xfs_extlen_t                    *aglen)
 {
         int                             error;
@@ -749,7 +747,7 @@ xfs_refcount_merge_extents(
             ulen < MAXREFCEXTLEN) {
                 *shape_changed = true;
                 return xfs_refcount_merge_center_extents(cur, &left, &cleft,
-                                &right, ulen, agbno, aglen);
+                                &right, ulen, aglen);
         }
 
         /* Try to merge left and cleft. */
@@ -778,7 +776,7 @@ xfs_refcount_merge_extents(
             ulen < MAXREFCEXTLEN) {
                 *shape_changed = true;
                 return xfs_refcount_merge_right_extent(cur, &right, &cright,
-                                agbno, aglen);
+                                aglen);
         }
 
         return error;
@@ -1356,9 +1354,7 @@ xfs_refcount_adjust_cow_extents(
         struct xfs_btree_cur    *cur,
         xfs_agblock_t           agbno,
         xfs_extlen_t            aglen,
-        enum xfs_refc_adjust_op adj,
-        struct xfs_defer_ops    *dfops,
-        struct xfs_owner_info   *oinfo)
+        enum xfs_refc_adjust_op adj)
 {
         struct xfs_refcount_irec        ext, tmp;
         int                             error;
@@ -1437,8 +1433,7 @@ xfs_refcount_adjust_cow(
         struct xfs_btree_cur    *cur,
         xfs_agblock_t           agbno,
         xfs_extlen_t            aglen,
-        enum xfs_refc_adjust_op adj,
-        struct xfs_defer_ops    *dfops)
+        enum xfs_refc_adjust_op adj)
 {
         bool                    shape_changed;
         int                     error;
@@ -1465,8 +1460,7 @@ xfs_refcount_adjust_cow(
                 goto out_error;
 
         /* Now that we've taken care of the ends, adjust the middle extents */
-        error = xfs_refcount_adjust_cow_extents(cur, agbno, aglen, adj,
-                        dfops, NULL);
+        error = xfs_refcount_adjust_cow_extents(cur, agbno, aglen, adj);
         if (error)
                 goto out_error;
 
@@ -1493,7 +1487,7 @@ __xfs_refcount_cow_alloc(
 
         /* Add refcount btree reservation */
         return xfs_refcount_adjust_cow(rcur, agbno, aglen,
-                        XFS_REFCOUNT_ADJUST_COW_ALLOC, dfops);
+                        XFS_REFCOUNT_ADJUST_COW_ALLOC);
 }
 
 /*
@@ -1511,7 +1505,7 @@ __xfs_refcount_cow_free(
 
         /* Remove refcount btree reservation */
         return xfs_refcount_adjust_cow(rcur, agbno, aglen,
-                        XFS_REFCOUNT_ADJUST_COW_FREE, dfops);
+                        XFS_REFCOUNT_ADJUST_COW_FREE);
 }
 
 /* Record a CoW staging extent in the refcount btree. */
@@ -1568,7 +1562,7 @@ struct xfs_refcount_recovery {
 /* Stuff an extent on the recovery list. */
 STATIC int
 xfs_refcount_recover_extent(
-        struct xfs_btree_cur            *cur,
+        struct xfs_btree_cur            *cur,
         union xfs_btree_rec             *rec,
         void                            *priv)
 {
diff --git a/fs/xfs/libxfs/xfs_refcount_btree.c b/fs/xfs/libxfs/xfs_refcount_btree.c
index 265fdcefcbae..375abfeb6267 100644
--- a/fs/xfs/libxfs/xfs_refcount_btree.c
+++ b/fs/xfs/libxfs/xfs_refcount_btree.c
@@ -373,7 +373,6 @@ xfs_refcountbt_init_cursor(
  */
 int
 xfs_refcountbt_maxrecs(
-        struct xfs_mount        *mp,
         int                     blocklen,
         bool                    leaf)
 {
@@ -390,7 +389,7 @@ void
 xfs_refcountbt_compute_maxlevels(
         struct xfs_mount                *mp)
 {
-        mp->m_refc_maxlevels = xfs_btree_compute_maxlevels(mp,
+        mp->m_refc_maxlevels = xfs_btree_compute_maxlevels(
                         mp->m_refc_mnr, mp->m_sb.sb_agblocks);
 }
 
@@ -400,7 +399,7 @@ xfs_refcountbt_calc_size(
         struct xfs_mount        *mp,
         unsigned long long      len)
 {
-        return xfs_btree_calc_size(mp, mp->m_refc_mnr, len);
+        return xfs_btree_calc_size(mp->m_refc_mnr, len);
 }
 
 /*
diff --git a/fs/xfs/libxfs/xfs_refcount_btree.h b/fs/xfs/libxfs/xfs_refcount_btree.h
index 9db008b955b7..2bc4694ef146 100644
--- a/fs/xfs/libxfs/xfs_refcount_btree.h
+++ b/fs/xfs/libxfs/xfs_refcount_btree.h
@@ -60,8 +60,7 @@ struct xfs_mount;
 extern struct xfs_btree_cur *xfs_refcountbt_init_cursor(struct xfs_mount *mp,
                 struct xfs_trans *tp, struct xfs_buf *agbp, xfs_agnumber_t agno,
                 struct xfs_defer_ops *dfops);
-extern int xfs_refcountbt_maxrecs(struct xfs_mount *mp, int blocklen,
-                bool leaf);
+extern int xfs_refcountbt_maxrecs(int blocklen, bool leaf);
 extern void xfs_refcountbt_compute_maxlevels(struct xfs_mount *mp);
 
 extern xfs_extlen_t xfs_refcountbt_calc_size(struct xfs_mount *mp,
diff --git a/fs/xfs/libxfs/xfs_rmap.c b/fs/xfs/libxfs/xfs_rmap.c
index 79822cf6ebe3..fba8d2718017 100644
--- a/fs/xfs/libxfs/xfs_rmap.c
+++ b/fs/xfs/libxfs/xfs_rmap.c
@@ -376,7 +376,6 @@ xfs_rmap_free_check_owner(
         struct xfs_mount        *mp,
         uint64_t                ltoff,
         struct xfs_rmap_irec    *rec,
-        xfs_fsblock_t           bno,
         xfs_filblks_t           len,
         uint64_t                owner,
         uint64_t                offset,
@@ -519,7 +518,7 @@ xfs_rmap_unmap(
                         bno + len, out_error);
 
         /* Check owner information. */
-        error = xfs_rmap_free_check_owner(mp, ltoff, &ltrec, bno, len, owner,
+        error = xfs_rmap_free_check_owner(mp, ltoff, &ltrec, len, owner,
                         offset, flags);
         if (error)
                 goto out_error;
diff --git a/fs/xfs/libxfs/xfs_rmap_btree.c b/fs/xfs/libxfs/xfs_rmap_btree.c
index 8b0d0de1cd11..d756e0b84abf 100644
--- a/fs/xfs/libxfs/xfs_rmap_btree.c
+++ b/fs/xfs/libxfs/xfs_rmap_btree.c
@@ -499,7 +499,6 @@ xfs_rmapbt_init_cursor(
  */
 int
 xfs_rmapbt_maxrecs(
-        struct xfs_mount        *mp,
         int                     blocklen,
         int                     leaf)
 {
@@ -534,7 +533,7 @@ xfs_rmapbt_compute_maxlevels(
         if (xfs_sb_version_hasreflink(&mp->m_sb))
                 mp->m_rmap_maxlevels = XFS_BTREE_MAXLEVELS;
         else
-                mp->m_rmap_maxlevels = xfs_btree_compute_maxlevels(mp,
+                mp->m_rmap_maxlevels = xfs_btree_compute_maxlevels(
                                 mp->m_rmap_mnr, mp->m_sb.sb_agblocks);
 }
 
@@ -544,7 +543,7 @@ xfs_rmapbt_calc_size(
         struct xfs_mount        *mp,
         unsigned long long      len)
 {
-        return xfs_btree_calc_size(mp, mp->m_rmap_mnr, len);
+        return xfs_btree_calc_size(mp->m_rmap_mnr, len);
 }
 
 /*
diff --git a/fs/xfs/libxfs/xfs_rmap_btree.h b/fs/xfs/libxfs/xfs_rmap_btree.h
index 19c08e933049..d68d96eed7ea 100644
--- a/fs/xfs/libxfs/xfs_rmap_btree.h
+++ b/fs/xfs/libxfs/xfs_rmap_btree.h
@@ -55,7 +55,7 @@ struct xfs_mount;
 struct xfs_btree_cur *xfs_rmapbt_init_cursor(struct xfs_mount *mp,
                                 struct xfs_trans *tp, struct xfs_buf *bp,
                                 xfs_agnumber_t agno);
-int xfs_rmapbt_maxrecs(struct xfs_mount *mp, int blocklen, int leaf);
+int xfs_rmapbt_maxrecs(int blocklen, int leaf);
 extern void xfs_rmapbt_compute_maxlevels(struct xfs_mount *mp);
 
 extern xfs_extlen_t xfs_rmapbt_calc_size(struct xfs_mount *mp,
diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index 53433cc024fd..d9b94bd5f689 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -756,15 +756,13 @@ xfs_sb_mount_common(
         mp->m_bmap_dmnr[0] = mp->m_bmap_dmxr[0] / 2;
         mp->m_bmap_dmnr[1] = mp->m_bmap_dmxr[1] / 2;
 
-        mp->m_rmap_mxr[0] = xfs_rmapbt_maxrecs(mp, sbp->sb_blocksize, 1);
-        mp->m_rmap_mxr[1] = xfs_rmapbt_maxrecs(mp, sbp->sb_blocksize, 0);
+        mp->m_rmap_mxr[0] = xfs_rmapbt_maxrecs(sbp->sb_blocksize, 1);
+        mp->m_rmap_mxr[1] = xfs_rmapbt_maxrecs(sbp->sb_blocksize, 0);
         mp->m_rmap_mnr[0] = mp->m_rmap_mxr[0] / 2;
         mp->m_rmap_mnr[1] = mp->m_rmap_mxr[1] / 2;
 
-        mp->m_refc_mxr[0] = xfs_refcountbt_maxrecs(mp, sbp->sb_blocksize,
-                        true);
-        mp->m_refc_mxr[1] = xfs_refcountbt_maxrecs(mp, sbp->sb_blocksize,
-                        false);
+        mp->m_refc_mxr[0] = xfs_refcountbt_maxrecs(sbp->sb_blocksize, true);
+        mp->m_refc_mxr[1] = xfs_refcountbt_maxrecs(sbp->sb_blocksize, false);
         mp->m_refc_mnr[0] = mp->m_refc_mxr[0] / 2;
         mp->m_refc_mnr[1] = mp->m_refc_mxr[1] / 2;
 
diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
index 5f17641f040f..3bccdf73e141 100644
--- a/fs/xfs/libxfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
@@ -734,8 +734,7 @@ xfs_calc_clear_agi_bucket_reservation(
  *    the xfs_disk_dquot_t: sizeof(struct xfs_disk_dquot)
  */
 STATIC uint
-xfs_calc_qm_setqlim_reservation(
-        struct xfs_mount        *mp)
+xfs_calc_qm_setqlim_reservation(void)
 {
         return xfs_calc_buf_res(1, sizeof(struct xfs_disk_dquot));
 }
@@ -772,8 +771,7 @@ xfs_calc_qm_quotaoff_reservation(
  *    the xfs_qoff_logitem_t: sizeof(struct xfs_qoff_logitem) * 2
  */
 STATIC uint
-xfs_calc_qm_quotaoff_end_reservation(
-        struct xfs_mount        *mp)
+xfs_calc_qm_quotaoff_end_reservation(void)
 {
         return sizeof(struct xfs_qoff_logitem) * 2;
 }
@@ -877,14 +875,14 @@ xfs_trans_resv_calc(
          * The following transactions are logged in logical format with
          * a default log count.
          */
-        resp->tr_qm_setqlim.tr_logres = xfs_calc_qm_setqlim_reservation(mp);
+        resp->tr_qm_setqlim.tr_logres = xfs_calc_qm_setqlim_reservation();
         resp->tr_qm_setqlim.tr_logcount = XFS_DEFAULT_LOG_COUNT;
 
         resp->tr_qm_quotaoff.tr_logres = xfs_calc_qm_quotaoff_reservation(mp);
         resp->tr_qm_quotaoff.tr_logcount = XFS_DEFAULT_LOG_COUNT;
 
         resp->tr_qm_equotaoff.tr_logres =
-                xfs_calc_qm_quotaoff_end_reservation(mp);
+                xfs_calc_qm_quotaoff_end_reservation();
         resp->tr_qm_equotaoff.tr_logcount = XFS_DEFAULT_LOG_COUNT;
 
         resp->tr_sb.tr_logres = xfs_calc_sb_reservation(mp);
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 05dee8fdd895..8cd8c412f52d 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -1326,7 +1326,6 @@ xfs_collapse_file_space(
         int                     error;
         struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
-        xfs_fileoff_t           stop_fsb = XFS_B_TO_FSB(mp, VFS_I(ip)->i_size);
         xfs_fileoff_t           next_fsb = XFS_B_TO_FSB(mp, offset + len);
         xfs_fileoff_t           shift_fsb = XFS_B_TO_FSB(mp, len);
         uint                    resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
@@ -1361,7 +1360,7 @@ xfs_collapse_file_space(
 
                 xfs_defer_init(&dfops, &first_block);
                 error = xfs_bmap_collapse_extents(tp, ip, &next_fsb, shift_fsb,
-                                &done, stop_fsb, &first_block, &dfops);
+                                &done, &first_block, &dfops);
                 if (error)
                         goto out_bmap_cancel;
 
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index ac669a10c62f..55661cbdb51b 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1754,7 +1754,6 @@ xfs_buftarg_shrink_count(
 
 void
 xfs_free_buftarg(
-        struct xfs_mount        *mp,
         struct xfs_buftarg      *btp)
 {
         unregister_shrinker(&btp->bt_shrinker);
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 2f4c91452861..edced162a674 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -388,7 +388,7 @@ xfs_buf_update_cksum(struct xfs_buf *bp, unsigned long cksum_offset)
  */
 extern xfs_buftarg_t *xfs_alloc_buftarg(struct xfs_mount *,
                         struct block_device *, struct dax_device *);
-extern void xfs_free_buftarg(struct xfs_mount *, struct xfs_buftarg *);
+extern void xfs_free_buftarg(struct xfs_buftarg *);
 extern void xfs_wait_buftarg(xfs_buftarg_t *);
 extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int);
 
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index 5131a6e25fc9..3f8722e51dbe 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -198,7 +198,7 @@ xfs_filestream_pick_ag(
                         goto next_ag;
                 }
 
-                longest = xfs_alloc_longest_free_extent(mp, pag,
+                longest = xfs_alloc_longest_free_extent(pag,
                                 xfs_alloc_min_freelist(mp, pag),
                                 xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));
                 if (((minlen && longest >= minlen) ||
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index c2a16b305f08..c09774ca53ae 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1301,7 +1301,6 @@ xfs_create(
 int
 xfs_create_tmpfile(
         struct xfs_inode        *dp,
-        struct dentry           *dentry,
         umode_t                 mode,
         struct xfs_inode        **ipp)
 {
@@ -2895,7 +2894,7 @@ xfs_rename_alloc_whiteout(
         struct xfs_inode        *tmpfile;
         int                     error;
 
-        error = xfs_create_tmpfile(dp, NULL, S_IFCHR | WHITEOUT_MODE, &tmpfile);
+        error = xfs_create_tmpfile(dp, S_IFCHR | WHITEOUT_MODE, &tmpfile);
         if (error)
                 return error;
 
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 64064126a859..1eebc53df7d7 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -393,8 +393,8 @@ int		xfs_lookup(struct xfs_inode *dp, struct xfs_name *name,
                            struct xfs_inode **ipp, struct xfs_name *ci_name);
 int             xfs_create(struct xfs_inode *dp, struct xfs_name *name,
                            umode_t mode, dev_t rdev, struct xfs_inode **ipp);
-int             xfs_create_tmpfile(struct xfs_inode *dp, struct dentry *dentry,
-                           umode_t mode, struct xfs_inode **ipp);
+int             xfs_create_tmpfile(struct xfs_inode *dp, umode_t mode,
+                           struct xfs_inode **ipp);
 int             xfs_remove(struct xfs_inode *dp, struct xfs_name *name,
                            struct xfs_inode *ip);
 int             xfs_link(struct xfs_inode *tdp, struct xfs_inode *sip,
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index e0307fbff911..c45acf0685e3 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -177,7 +177,7 @@ xfs_generic_create(
         if (!tmpfile) {
                 error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip);
         } else {
-                error = xfs_create_tmpfile(XFS_I(dir), dentry, mode, &ip);
+                error = xfs_create_tmpfile(XFS_I(dir), mode, &ip);
         }
         if (unlikely(error))
                 goto out_free_acl;
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index b9c9c848146b..2fcd9ed5d075 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -560,7 +560,6 @@ xfs_log_done(
  */
 int
 xfs_log_notify(
-        struct xfs_mount        *mp,
         struct xlog_in_core     *iclog,
         xfs_log_callback_t      *cb)
 {
diff --git a/fs/xfs/xfs_log.h b/fs/xfs/xfs_log.h
index 7e2d62922a16..fa8ad31d587f 100644
--- a/fs/xfs/xfs_log.h
+++ b/fs/xfs/xfs_log.h
@@ -141,8 +141,7 @@ int	xfs_log_mount_cancel(struct xfs_mount *);
 xfs_lsn_t xlog_assign_tail_lsn(struct xfs_mount *mp);
 xfs_lsn_t xlog_assign_tail_lsn_locked(struct xfs_mount *mp);
 void      xfs_log_space_wake(struct xfs_mount *mp);
-int       xfs_log_notify(struct xfs_mount       *mp,
-                         struct xlog_in_core    *iclog,
+int       xfs_log_notify(struct xlog_in_core    *iclog,
                          struct xfs_log_callback *callback_entry);
 int       xfs_log_release_iclog(struct xfs_mount *mp,
                          struct xlog_in_core     *iclog);
diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index cb376ac8a595..4668403b1741 100644
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -848,7 +848,7 @@ restart:
         /* attach all the transactions w/ busy extents to iclog */
         ctx->log_cb.cb_func = xlog_cil_committed;
         ctx->log_cb.cb_arg = ctx;
-        error = xfs_log_notify(log->l_mp, commit_iclog, &ctx->log_cb);
+        error = xfs_log_notify(commit_iclog, &ctx->log_cb);
         if (error)
                 goto out_abort;
 
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 612c1d5348b3..d71424052917 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -722,7 +722,7 @@ xfs_close_devices(
                 struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
                 struct dax_device *dax_logdev = mp->m_logdev_targp->bt_daxdev;
 
-                xfs_free_buftarg(mp, mp->m_logdev_targp);
+                xfs_free_buftarg(mp->m_logdev_targp);
                 xfs_blkdev_put(logdev);
                 fs_put_dax(dax_logdev);
         }
@@ -730,11 +730,11 @@ xfs_close_devices(
                 struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
                 struct dax_device *dax_rtdev = mp->m_rtdev_targp->bt_daxdev;
 
-                xfs_free_buftarg(mp, mp->m_rtdev_targp);
+                xfs_free_buftarg(mp->m_rtdev_targp);
                 xfs_blkdev_put(rtdev);
                 fs_put_dax(dax_rtdev);
         }
-        xfs_free_buftarg(mp, mp->m_ddev_targp);
+        xfs_free_buftarg(mp->m_ddev_targp);
         fs_put_dax(dax_ddev);
 }
 
@@ -808,9 +808,9 @@ xfs_open_devices(
 
  out_free_rtdev_targ:
         if (mp->m_rtdev_targp)
-                xfs_free_buftarg(mp, mp->m_rtdev_targp);
+                xfs_free_buftarg(mp->m_rtdev_targp);
  out_free_ddev_targ:
-        xfs_free_buftarg(mp, mp->m_ddev_targp);
+        xfs_free_buftarg(mp->m_ddev_targp);
  out_close_rtdev:
         xfs_blkdev_put(rtdev);
         fs_put_dax(dax_rtdev);
@@ -1247,7 +1247,6 @@ xfs_quiesce_attr(
 STATIC int
 xfs_test_remount_options(
         struct super_block      *sb,
-        struct xfs_mount        *mp,
         char                    *options)
 {
         int                     error = 0;
@@ -1278,7 +1277,7 @@ xfs_fs_remount(
         int                     error;
 
         /* First, check for complete junk; i.e. invalid options */
-        error = xfs_test_remount_options(sb, mp, options);
+        error = xfs_test_remount_options(sb, options);
         if (error)
                 return error;