Merge branch 'xfs-unused-args-cleanup' into for-next

43 files changed, 113 insertions, 166 deletions

diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c
index cc1eadcbb049..8358f1ded94d 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/xfs_alloc_btree.c
@@ -70,7 +70,6 @@ xfs_allocbt_alloc_block(
         struct xfs_btree_cur    *cur,
         union xfs_btree_ptr     *start,
         union xfs_btree_ptr     *new,
-        int                     length,
         int                     *stat)
 {
         int                     error;
diff --git a/fs/xfs/xfs_attr_remote.c b/fs/xfs/xfs_attr_remote.c
index d2e6e948cec7..0f0679a134e2 100644
--- a/fs/xfs/xfs_attr_remote.c
+++ b/fs/xfs/xfs_attr_remote.c
@@ -68,7 +68,6 @@ xfs_attr3_rmt_blocks(
  */
 static bool
 xfs_attr3_rmt_hdr_ok(
-        struct xfs_mount        *mp,
         void                    *ptr,
         xfs_ino_t               ino,
         uint32_t                offset,
@@ -251,7 +250,7 @@ xfs_attr_rmtval_copyout(
                 byte_cnt = min(*valuelen, byte_cnt);
 
                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
-                        if (!xfs_attr3_rmt_hdr_ok(mp, src, ino, *offset,
+                        if (!xfs_attr3_rmt_hdr_ok(src, ino, *offset,
                                                   byte_cnt, bno)) {
                                 xfs_alert(mp,
 "remote attribute header mismatch bno/off/len/owner (0x%llx/0x%x/Ox%x/0x%llx)",
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index f0efc7e970ef..37b8d3c66745 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -94,7 +94,7 @@ xfs_bmap_compute_maxlevels(
                 maxleafents = MAXAEXTNUM;
                 sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);
         }
-        maxrootrecs = xfs_bmdr_maxrecs(mp, sz, 0);
+        maxrootrecs = xfs_bmdr_maxrecs(sz, 0);
         minleafrecs = mp->m_bmap_dmnr[0];
         minnoderecs = mp->m_bmap_dmnr[1];
         maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
@@ -233,7 +233,6 @@ xfs_default_attroffset(
  */
 STATIC void
 xfs_bmap_forkoff_reset(
-        xfs_mount_t     *mp,
         xfs_inode_t     *ip,
         int             whichfork)
 {
@@ -905,7 +904,7 @@ xfs_bmap_local_to_extents_empty(
         ASSERT(ifp->if_bytes == 0);
         ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0);
 
-        xfs_bmap_forkoff_reset(ip->i_mount, ip, whichfork);
+        xfs_bmap_forkoff_reset(ip, whichfork);
         ifp->if_flags &= ~XFS_IFINLINE;
         ifp->if_flags |= XFS_IFEXTENTS;
         XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
@@ -1675,7 +1674,6 @@ xfs_bmap_isaeof(
  */
 int
 xfs_bmap_last_offset(
-        struct xfs_trans        *tp,
         struct xfs_inode        *ip,
         xfs_fileoff_t           *last_block,
         int                     whichfork)
diff --git a/fs/xfs/xfs_bmap.h b/fs/xfs/xfs_bmap.h
index f84bd7af43be..38ba36e9b2f0 100644
--- a/fs/xfs/xfs_bmap.h
+++ b/fs/xfs/xfs_bmap.h
@@ -156,8 +156,8 @@ int	xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_extlen_t len, xfs_fileoff_t *unused, int whichfork);
 int     xfs_bmap_last_before(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_fileoff_t *last_block, int whichfork);
-int     xfs_bmap_last_offset(struct xfs_trans *tp, struct xfs_inode *ip,
-                xfs_fileoff_t *unused, int whichfork);
+int     xfs_bmap_last_offset(struct xfs_inode *ip, xfs_fileoff_t *unused,
+                int whichfork);
 int     xfs_bmap_one_block(struct xfs_inode *ip, int whichfork);
 int     xfs_bmap_read_extents(struct xfs_trans *tp, struct xfs_inode *ip,
                 int whichfork);
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/xfs_bmap_btree.c
index 818d546664e7..948836c4fd90 100644
--- a/fs/xfs/xfs_bmap_btree.c
+++ b/fs/xfs/xfs_bmap_btree.c
@@ -84,7 +84,7 @@ xfs_bmdr_to_bmbt(
         rblock->bb_level = dblock->bb_level;
         ASSERT(be16_to_cpu(rblock->bb_level) > 0);
         rblock->bb_numrecs = dblock->bb_numrecs;
-        dmxr = xfs_bmdr_maxrecs(mp, dblocklen, 0);
+        dmxr = xfs_bmdr_maxrecs(dblocklen, 0);
         fkp = XFS_BMDR_KEY_ADDR(dblock, 1);
         tkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1);
         fpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr);
@@ -443,7 +443,7 @@ xfs_bmbt_to_bmdr(
         ASSERT(rblock->bb_level != 0);
         dblock->bb_level = rblock->bb_level;
         dblock->bb_numrecs = rblock->bb_numrecs;
-        dmxr = xfs_bmdr_maxrecs(mp, dblocklen, 0);
+        dmxr = xfs_bmdr_maxrecs(dblocklen, 0);
         fkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1);
         tkp = XFS_BMDR_KEY_ADDR(dblock, 1);
         fpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen);
@@ -519,7 +519,6 @@ xfs_bmbt_alloc_block(
         struct xfs_btree_cur    *cur,
         union xfs_btree_ptr     *start,
         union xfs_btree_ptr     *new,
-        int                     length,
         int                     *stat)
 {
         xfs_alloc_arg_t         args;           /* block allocation args */
@@ -672,8 +671,7 @@ xfs_bmbt_get_dmaxrecs(
 {
         if (level != cur->bc_nlevels - 1)
                 return cur->bc_mp->m_bmap_dmxr[level != 0];
-        return xfs_bmdr_maxrecs(cur->bc_mp, cur->bc_private.b.forksize,
-                                level == 0);
+        return xfs_bmdr_maxrecs(cur->bc_private.b.forksize, level == 0);
 }
 
 STATIC void
@@ -914,7 +912,6 @@ xfs_bmbt_maxrecs(
  */
 int
 xfs_bmdr_maxrecs(
-        struct xfs_mount        *mp,
         int                     blocklen,
         int                     leaf)
 {
diff --git a/fs/xfs/xfs_bmap_btree.h b/fs/xfs/xfs_bmap_btree.h
index 6e42e1e50b89..819a8a4dee95 100644
--- a/fs/xfs/xfs_bmap_btree.h
+++ b/fs/xfs/xfs_bmap_btree.h
@@ -130,7 +130,7 @@ extern void xfs_bmbt_to_bmdr(struct xfs_mount *, struct xfs_btree_block *, int,
                         xfs_bmdr_block_t *, int);
 
 extern int xfs_bmbt_get_maxrecs(struct xfs_btree_cur *, int level);
-extern int xfs_bmdr_maxrecs(struct xfs_mount *, int blocklen, int leaf);
+extern int xfs_bmdr_maxrecs(int blocklen, int leaf);
 extern int xfs_bmbt_maxrecs(struct xfs_mount *, int blocklen, int leaf);
 
 extern int xfs_bmbt_change_owner(struct xfs_trans *tp, struct xfs_inode *ip,
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/xfs_btree.c
index e80d59fdf89a..c13d650fdb99 100644
--- a/fs/xfs/xfs_btree.c
+++ b/fs/xfs/xfs_btree.c
@@ -1159,7 +1159,6 @@ STATIC int
 xfs_btree_read_buf_block(
         struct xfs_btree_cur    *cur,
         union xfs_btree_ptr     *ptr,
-        int                     level,
         int                     flags,
         struct xfs_btree_block  **block,
         struct xfs_buf          **bpp)
@@ -1517,8 +1516,8 @@ xfs_btree_increment(
                 union xfs_btree_ptr     *ptrp;
 
                 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
-                error = xfs_btree_read_buf_block(cur, ptrp, --lev,
-                                                        0, &block, &bp);
+                --lev;
+                error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp);
                 if (error)
                         goto error0;
 
@@ -1616,8 +1615,8 @@ xfs_btree_decrement(
                 union xfs_btree_ptr     *ptrp;
 
                 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
-                error = xfs_btree_read_buf_block(cur, ptrp, --lev,
-                                                        0, &block, &bp);
+                --lev;
+                error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp);
                 if (error)
                         goto error0;
                 xfs_btree_setbuf(cur, lev, bp);
@@ -1667,7 +1666,7 @@ xfs_btree_lookup_get_block(
                 return 0;
         }
 
-        error = xfs_btree_read_buf_block(cur, pp, level, 0, blkp, &bp);
+        error = xfs_btree_read_buf_block(cur, pp, 0, blkp, &bp);
         if (error)
                 return error;
 
@@ -2018,7 +2017,7 @@ xfs_btree_lshift(
                 goto out0;
 
         /* Set up the left neighbor as "left". */
-        error = xfs_btree_read_buf_block(cur, &lptr, level, 0, &left, &lbp);
+        error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
         if (error)
                 goto error0;
 
@@ -2202,7 +2201,7 @@ xfs_btree_rshift(
                 goto out0;
 
         /* Set up the right neighbor as "right". */
-        error = xfs_btree_read_buf_block(cur, &rptr, level, 0, &right, &rbp);
+        error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
         if (error)
                 goto error0;
 
@@ -2372,7 +2371,7 @@ xfs_btree_split(
         xfs_btree_buf_to_ptr(cur, lbp, &lptr);
 
         /* Allocate the new block. If we can't do it, we're toast. Give up. */
-        error = cur->bc_ops->alloc_block(cur, &lptr, &rptr, 1, stat);
+        error = cur->bc_ops->alloc_block(cur, &lptr, &rptr, stat);
         if (error)
                 goto error0;
         if (*stat == 0)
@@ -2470,7 +2469,7 @@ xfs_btree_split(
          * point back to right instead of to left.
          */
         if (!xfs_btree_ptr_is_null(cur, &rrptr)) {
-                error = xfs_btree_read_buf_block(cur, &rrptr, level,
+                error = xfs_btree_read_buf_block(cur, &rrptr,
                                                         0, &rrblock, &rrbp);
                 if (error)
                         goto error0;
@@ -2545,7 +2544,7 @@ xfs_btree_new_iroot(
         pp = xfs_btree_ptr_addr(cur, 1, block);
 
         /* Allocate the new block. If we can't do it, we're toast. Give up. */
-        error = cur->bc_ops->alloc_block(cur, pp, &nptr, 1, stat);
+        error = cur->bc_ops->alloc_block(cur, pp, &nptr, stat);
         if (error)
                 goto error0;
         if (*stat == 0) {
@@ -2649,7 +2648,7 @@ xfs_btree_new_root(
         cur->bc_ops->init_ptr_from_cur(cur, &rptr);
 
         /* Allocate the new block. If we can't do it, we're toast. Give up. */
-        error = cur->bc_ops->alloc_block(cur, &rptr, &lptr, 1, stat);
+        error = cur->bc_ops->alloc_block(cur, &rptr, &lptr, stat);
         if (error)
                 goto error0;
         if (*stat == 0)
@@ -2684,8 +2683,7 @@ xfs_btree_new_root(
                 lbp = bp;
                 xfs_btree_buf_to_ptr(cur, lbp, &lptr);
                 left = block;
-                error = xfs_btree_read_buf_block(cur, &rptr,
-                                        cur->bc_nlevels - 1, 0, &right, &rbp);
+                error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
                 if (error)
                         goto error0;
                 bp = rbp;
@@ -2696,8 +2694,7 @@ xfs_btree_new_root(
                 xfs_btree_buf_to_ptr(cur, rbp, &rptr);
                 right = block;
                 xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
-                error = xfs_btree_read_buf_block(cur, &lptr,
-                                        cur->bc_nlevels - 1, 0, &left, &lbp);
+                error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
                 if (error)
                         goto error0;
                 bp = lbp;
@@ -3649,8 +3646,7 @@ xfs_btree_delrec(
                 rptr = cptr;
                 right = block;
                 rbp = bp;
-                error = xfs_btree_read_buf_block(cur, &lptr, level,
-                                                        0, &left, &lbp);
+                error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
                 if (error)
                         goto error0;
 
@@ -3667,8 +3663,7 @@ xfs_btree_delrec(
                 lptr = cptr;
                 left = block;
                 lbp = bp;
-                error = xfs_btree_read_buf_block(cur, &rptr, level,
-                                                        0, &right, &rbp);
+                error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
                 if (error)
                         goto error0;
 
@@ -3740,8 +3735,7 @@ xfs_btree_delrec(
         /* If there is a right sibling, point it to the remaining block. */
         xfs_btree_get_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
         if (!xfs_btree_ptr_is_null(cur, &cptr)) {
-                error = xfs_btree_read_buf_block(cur, &cptr, level,
-                                                        0, &rrblock, &rrbp);
+                error = xfs_btree_read_buf_block(cur, &cptr, 0, &rrblock, &rrbp);
                 if (error)
                         goto error0;
                 xfs_btree_set_sibling(cur, rrblock, &lptr, XFS_BB_LEFTSIB);
diff --git a/fs/xfs/xfs_btree.h b/fs/xfs/xfs_btree.h
index 91e34f21bace..875f6876ff48 100644
--- a/fs/xfs/xfs_btree.h
+++ b/fs/xfs/xfs_btree.h
@@ -129,7 +129,7 @@ struct xfs_btree_ops {
         int     (*alloc_block)(struct xfs_btree_cur *cur,
                                union xfs_btree_ptr *start_bno,
                                union xfs_btree_ptr *new_bno,
-                               int length, int *stat);
+                               int *stat);
         int     (*free_block)(struct xfs_btree_cur *cur, struct xfs_buf *bp);
 
         /* update last record information */
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index cb10a0aaab3a..7a34a1ae6552 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -216,8 +216,7 @@ _xfs_buf_alloc(
 STATIC int
 _xfs_buf_get_pages(
         xfs_buf_t               *bp,
-        int                     page_count,
-        xfs_buf_flags_t         flags)
+        int                     page_count)
 {
         /* Make sure that we have a page list */
         if (bp->b_pages == NULL) {
@@ -330,7 +329,7 @@ use_alloc_page:
         end = (BBTOB(bp->b_maps[0].bm_bn + bp->b_length) + PAGE_SIZE - 1)
                                                                 >> PAGE_SHIFT;
         page_count = end - start;
-        error = _xfs_buf_get_pages(bp, page_count, flags);
+        error = _xfs_buf_get_pages(bp, page_count);
         if (unlikely(error))
                 return error;
 
@@ -778,7 +777,7 @@ xfs_buf_associate_memory(
         bp->b_pages = NULL;
         bp->b_addr = mem;
 
-        rval = _xfs_buf_get_pages(bp, page_count, 0);
+        rval = _xfs_buf_get_pages(bp, page_count);
         if (rval)
                 return rval;
 
@@ -811,7 +810,7 @@ xfs_buf_get_uncached(
                 goto fail;
 
         page_count = PAGE_ALIGN(numblks << BBSHIFT) >> PAGE_SHIFT;
-        error = _xfs_buf_get_pages(bp, page_count, 0);
+        error = _xfs_buf_get_pages(bp, page_count);
         if (error)
                 goto fail_free_buf;
 
@@ -1615,7 +1614,6 @@ xfs_free_buftarg(
 int
 xfs_setsize_buftarg(
         xfs_buftarg_t           *btp,
-        unsigned int            blocksize,
         unsigned int            sectorsize)
 {
         /* Set up metadata sector size info */
@@ -1650,16 +1648,13 @@ xfs_setsize_buftarg_early(
         xfs_buftarg_t           *btp,
         struct block_device     *bdev)
 {
-        return xfs_setsize_buftarg(btp, PAGE_SIZE,
-                                   bdev_logical_block_size(bdev));
+        return xfs_setsize_buftarg(btp, bdev_logical_block_size(bdev));
 }
 
 xfs_buftarg_t *
 xfs_alloc_buftarg(
         struct xfs_mount        *mp,
-        struct block_device     *bdev,
-        int                     external,
-        const char              *fsname)
+        struct block_device     *bdev)
 {
         xfs_buftarg_t           *btp;
 
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index b8a3abf6cf47..0e47fd1fedba 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -387,10 +387,10 @@ xfs_buf_update_cksum(struct xfs_buf *bp, unsigned long cksum_offset)
  *      Handling of buftargs.
  */
 extern xfs_buftarg_t *xfs_alloc_buftarg(struct xfs_mount *,
-                        struct block_device *, int, const char *);
+                        struct block_device *);
 extern void xfs_free_buftarg(struct xfs_mount *, struct xfs_buftarg *);
 extern void xfs_wait_buftarg(xfs_buftarg_t *);
-extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int, unsigned int);
+extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int);
 
 #define xfs_getsize_buftarg(buftarg)    block_size((buftarg)->bt_bdev)
 #define xfs_readonly_buftarg(buftarg)   bdev_read_only((buftarg)->bt_bdev)
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 8752821443be..64b17f5bed9a 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -812,7 +812,6 @@ xfs_buf_item_init(
  */
 static void
 xfs_buf_item_log_segment(
-        struct xfs_buf_log_item *bip,
         uint                    first,
         uint                    last,
         uint                    *map)
@@ -920,7 +919,7 @@ xfs_buf_item_log(
                 if (end > last)
                         end = last;
 
-                xfs_buf_item_log_segment(bip, first, end,
+                xfs_buf_item_log_segment(first, end,
                                          &bip->bli_formats[i].blf_data_map[0]);
 
                 start += bp->b_maps[i].bm_len;
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 6cc5f6785a77..9eec594cc25a 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -2462,7 +2462,6 @@ xfs_buf_map_from_irec(
  */
 static int
 xfs_dabuf_map(
-        struct xfs_trans        *trans,
         struct xfs_inode        *dp,
         xfs_dablk_t             bno,
         xfs_daddr_t             mappedbno,
@@ -2558,7 +2557,7 @@ xfs_da_get_buf(
         *bpp = NULL;
         mapp = &map;
         nmap = 1;
-        error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
+        error = xfs_dabuf_map(dp, bno, mappedbno, whichfork,
                                 &mapp, &nmap);
         if (error) {
                 /* mapping a hole is not an error, but we don't continue */
@@ -2606,7 +2605,7 @@ xfs_da_read_buf(
         *bpp = NULL;
         mapp = &map;
         nmap = 1;
-        error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
+        error = xfs_dabuf_map(dp, bno, mappedbno, whichfork,
                                 &mapp, &nmap);
         if (error) {
                 /* mapping a hole is not an error, but we don't continue */
@@ -2679,7 +2678,6 @@ out_free:
  */
 xfs_daddr_t
 xfs_da_reada_buf(
-        struct xfs_trans        *trans,
         struct xfs_inode        *dp,
         xfs_dablk_t             bno,
         xfs_daddr_t             mappedbno,
@@ -2693,7 +2691,7 @@ xfs_da_reada_buf(
 
         mapp = &map;
         nmap = 1;
-        error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
+        error = xfs_dabuf_map(dp, bno, mappedbno, whichfork,
                                 &mapp, &nmap);
         if (error) {
                 /* mapping a hole is not an error, but we don't continue */
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h
index 201c6091d26a..c824a0aa039f 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/xfs_da_btree.h
@@ -185,9 +185,9 @@ int	xfs_da_read_buf(struct xfs_trans *trans, struct xfs_inode *dp,
                                xfs_dablk_t bno, xfs_daddr_t mappedbno,
                                struct xfs_buf **bpp, int whichfork,
                                const struct xfs_buf_ops *ops);
-xfs_daddr_t     xfs_da_reada_buf(struct xfs_trans *trans, struct xfs_inode *dp,
-                                xfs_dablk_t bno, xfs_daddr_t mapped_bno,
-                                int whichfork, const struct xfs_buf_ops *ops);
+xfs_daddr_t     xfs_da_reada_buf(struct xfs_inode *dp, xfs_dablk_t bno,
+                                xfs_daddr_t mapped_bno, int whichfork,
+                                const struct xfs_buf_ops *ops);
 int     xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
                                           struct xfs_buf *dead_buf);
 
diff --git a/fs/xfs/xfs_da_format.h b/fs/xfs/xfs_da_format.h
index a19d3f8f639c..1432b576b4a7 100644
--- a/fs/xfs/xfs_da_format.h
+++ b/fs/xfs/xfs_da_format.h
@@ -541,7 +541,7 @@ xfs_dir2_leaf_bests_p(struct xfs_dir2_leaf_tail *ltp)
  * Convert dataptr to byte in file space
  */
 static inline xfs_dir2_off_t
-xfs_dir2_dataptr_to_byte(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
+xfs_dir2_dataptr_to_byte(xfs_dir2_dataptr_t dp)
 {
         return (xfs_dir2_off_t)dp << XFS_DIR2_DATA_ALIGN_LOG;
 }
@@ -550,7 +550,7 @@ xfs_dir2_dataptr_to_byte(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
  * Convert byte in file space to dataptr.  It had better be aligned.
  */
 static inline xfs_dir2_dataptr_t
-xfs_dir2_byte_to_dataptr(struct xfs_mount *mp, xfs_dir2_off_t by)
+xfs_dir2_byte_to_dataptr(xfs_dir2_off_t by)
 {
         return (xfs_dir2_dataptr_t)(by >> XFS_DIR2_DATA_ALIGN_LOG);
 }
@@ -571,7 +571,7 @@ xfs_dir2_byte_to_db(struct xfs_mount *mp, xfs_dir2_off_t by)
 static inline xfs_dir2_db_t
 xfs_dir2_dataptr_to_db(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
 {
-        return xfs_dir2_byte_to_db(mp, xfs_dir2_dataptr_to_byte(mp, dp));
+        return xfs_dir2_byte_to_db(mp, xfs_dir2_dataptr_to_byte(dp));
 }
 
 /*
@@ -590,7 +590,7 @@ xfs_dir2_byte_to_off(struct xfs_mount *mp, xfs_dir2_off_t by)
 static inline xfs_dir2_data_aoff_t
 xfs_dir2_dataptr_to_off(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
 {
-        return xfs_dir2_byte_to_off(mp, xfs_dir2_dataptr_to_byte(mp, dp));
+        return xfs_dir2_byte_to_off(mp, xfs_dir2_dataptr_to_byte(dp));
 }
 
 /*
@@ -629,7 +629,7 @@ static inline xfs_dir2_dataptr_t
 xfs_dir2_db_off_to_dataptr(struct xfs_mount *mp, xfs_dir2_db_t db,
                            xfs_dir2_data_aoff_t o)
 {
-        return xfs_dir2_byte_to_dataptr(mp, xfs_dir2_db_off_to_byte(mp, db, o));
+        return xfs_dir2_byte_to_dataptr(xfs_dir2_db_off_to_byte(mp, db, o));
 }
 
 /*
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index fda46253966a..e365c98c0f1e 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -244,7 +244,7 @@ xfs_dir_createname(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isblock(tp, dp, &v);
+        rval = xfs_dir2_isblock(dp, &v);
         if (rval)
                 goto out_free;
         if (v) {
@@ -252,7 +252,7 @@ xfs_dir_createname(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isleaf(tp, dp, &v);
+        rval = xfs_dir2_isleaf(dp, &v);
         if (rval)
                 goto out_free;
         if (v)
@@ -336,7 +336,7 @@ xfs_dir_lookup(
                 goto out_check_rval;
         }
 
-        rval = xfs_dir2_isblock(tp, dp, &v);
+        rval = xfs_dir2_isblock(dp, &v);
         if (rval)
                 goto out_free;
         if (v) {
@@ -344,7 +344,7 @@ xfs_dir_lookup(
                 goto out_check_rval;
         }
 
-        rval = xfs_dir2_isleaf(tp, dp, &v);
+        rval = xfs_dir2_isleaf(dp, &v);
         if (rval)
                 goto out_free;
         if (v)
@@ -408,7 +408,7 @@ xfs_dir_removename(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isblock(tp, dp, &v);
+        rval = xfs_dir2_isblock(dp, &v);
         if (rval)
                 goto out_free;
         if (v) {
@@ -416,7 +416,7 @@ xfs_dir_removename(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isleaf(tp, dp, &v);
+        rval = xfs_dir2_isleaf(dp, &v);
         if (rval)
                 goto out_free;
         if (v)
@@ -472,7 +472,7 @@ xfs_dir_replace(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isblock(tp, dp, &v);
+        rval = xfs_dir2_isblock(dp, &v);
         if (rval)
                 goto out_free;
         if (v) {
@@ -480,7 +480,7 @@ xfs_dir_replace(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isleaf(tp, dp, &v);
+        rval = xfs_dir2_isleaf(dp, &v);
         if (rval)
                 goto out_free;
         if (v)
@@ -531,7 +531,7 @@ xfs_dir_canenter(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isblock(tp, dp, &v);
+        rval = xfs_dir2_isblock(dp, &v);
         if (rval)
                 goto out_free;
         if (v) {
@@ -539,7 +539,7 @@ xfs_dir_canenter(
                 goto out_free;
         }
 
-        rval = xfs_dir2_isleaf(tp, dp, &v);
+        rval = xfs_dir2_isleaf(dp, &v);
         if (rval)
                 goto out_free;
         if (v)
@@ -607,7 +607,6 @@ xfs_dir2_grow_inode(
  */
 int
 xfs_dir2_isblock(
-        xfs_trans_t     *tp,
         xfs_inode_t     *dp,
         int             *vp)            /* out: 1 is block, 0 is not block */
 {
@@ -616,7 +615,7 @@ xfs_dir2_isblock(
         int             rval;
 
         mp = dp->i_mount;
-        if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK)))
+        if ((rval = xfs_bmap_last_offset(dp, &last, XFS_DATA_FORK)))
                 return rval;
         rval = XFS_FSB_TO_B(mp, last) == mp->m_dirblksize;
         ASSERT(rval == 0 || dp->i_d.di_size == mp->m_dirblksize);
@@ -629,7 +628,6 @@ xfs_dir2_isblock(
  */
 int
 xfs_dir2_isleaf(
-        xfs_trans_t     *tp,
         xfs_inode_t     *dp,
         int             *vp)            /* out: 1 is leaf, 0 is not leaf */
 {
@@ -638,7 +636,7 @@ xfs_dir2_isleaf(
         int             rval;
 
         mp = dp->i_mount;
-        if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK)))
+        if ((rval = xfs_bmap_last_offset(dp, &last, XFS_DATA_FORK)))
                 return rval;
         *vp = last == mp->m_dirleafblk + (1 << mp->m_sb.sb_dirblklog);
         return 0;
diff --git a/fs/xfs/xfs_dir2.h b/fs/xfs/xfs_dir2.h
index cec70e0781ab..64a6b19c2fd0 100644
--- a/fs/xfs/xfs_dir2.h
+++ b/fs/xfs/xfs_dir2.h
@@ -142,8 +142,8 @@ extern int xfs_dir2_sf_to_block(struct xfs_da_args *args);
 /*
  * Interface routines used by userspace utilities
  */
-extern int xfs_dir2_isblock(struct xfs_trans *tp, struct xfs_inode *dp, int *r);
-extern int xfs_dir2_isleaf(struct xfs_trans *tp, struct xfs_inode *dp, int *r);
+extern int xfs_dir2_isblock(struct xfs_inode *dp, int *r);
+extern int xfs_dir2_isleaf(struct xfs_inode *dp, int *r);
 extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db,
                                 struct xfs_buf *bp);
 
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 4f6a38cb83a4..dd9d00515582 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -319,7 +319,6 @@ xfs_dir2_block_compact(
                 (xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),
                 (xfs_dir2_data_aoff_t)((be32_to_cpu(btp->stale) - 1) * sizeof(*blp)),
                 needlog, &needscan);
-        blp += be32_to_cpu(btp->stale) - 1;
         btp->stale = cpu_to_be32(1);
         /*
          * If we now need to rebuild the bestfree map, do so.
@@ -537,7 +536,7 @@ xfs_dir2_block_addname(
          * Fill in the leaf entry.
          */
         blp[mid].hashval = cpu_to_be32(args->hashval);
-        blp[mid].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
+        blp[mid].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
                                 (char *)dep - (char *)hdr));
         xfs_dir2_block_log_leaf(tp, bp, lfloglow, lfloghigh);
         /*
@@ -1170,7 +1169,7 @@ xfs_dir2_sf_to_block(
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
         xfs_dir2_data_log_entry(tp, dp, bp, dep);
         blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);
-        blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
+        blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
                                 (char *)dep - (char *)hdr));
         /*
          * Create entry for ..
@@ -1184,7 +1183,7 @@ xfs_dir2_sf_to_block(
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
         xfs_dir2_data_log_entry(tp, dp, bp, dep);
         blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
-        blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
+        blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
                                 (char *)dep - (char *)hdr));
         offset = dp->d_ops->data_first_offset;
         /*
@@ -1238,7 +1237,7 @@ xfs_dir2_sf_to_block(
                 name.len = sfep->namelen;
                 blp[2 + i].hashval = cpu_to_be32(mp->m_dirnameops->
                                                         hashname(&name));
-                blp[2 + i].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
+                blp[2 + i].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
                                                  (char *)dep - (char *)hdr));
                 offset = (int)((char *)(tagp + 1) - (char *)hdr);
                 if (++i == sfp->count)
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index afa4ad523f3f..bae8b5b8d1c2 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -329,12 +329,11 @@ xfs_dir3_data_read(
 
 int
 xfs_dir3_data_readahead(
-        struct xfs_trans        *tp,
         struct xfs_inode        *dp,
         xfs_dablk_t             bno,
         xfs_daddr_t             mapped_bno)
 {
-        return xfs_da_reada_buf(tp, dp, bno, mapped_bno,
+        return xfs_da_reada_buf(dp, bno, mapped_bno,
                                 XFS_DATA_FORK, &xfs_dir3_data_reada_buf_ops);
 }
 
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index d36e97df1187..f571723e2378 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -1708,7 +1708,7 @@ xfs_dir2_node_to_leaf(
         /*
          * Get the last offset in the file.
          */
-        if ((error = xfs_bmap_last_offset(tp, dp, &fo, XFS_DATA_FORK))) {
+        if ((error = xfs_bmap_last_offset(dp, &fo, XFS_DATA_FORK))) {
                 return error;
         }
         fo -= mp->m_dirblkfsbs;
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index cb434d732681..9cb91ee0914b 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -1727,7 +1727,7 @@ xfs_dir2_node_addname_int(
         if (dbno == -1) {
                 xfs_fileoff_t   fo;             /* freespace block number */
 
-                if ((error = xfs_bmap_last_offset(tp, dp, &fo, XFS_DATA_FORK)))
+                if ((error = xfs_bmap_last_offset(dp, &fo, XFS_DATA_FORK)))
                         return error;
                 lastfbno = xfs_dir2_da_to_db(mp, (xfs_dablk_t)fo);
                 fbno = ifbno;
diff --git a/fs/xfs/xfs_dir2_priv.h b/fs/xfs/xfs_dir2_priv.h
index 8b9d2281f85b..2429960739e9 100644
--- a/fs/xfs/xfs_dir2_priv.h
+++ b/fs/xfs/xfs_dir2_priv.h
@@ -54,8 +54,8 @@ extern int xfs_dir2_leaf_to_block(struct xfs_da_args *args,
 extern int __xfs_dir3_data_check(struct xfs_inode *dp, struct xfs_buf *bp);
 extern int xfs_dir3_data_read(struct xfs_trans *tp, struct xfs_inode *dp,
                 xfs_dablk_t bno, xfs_daddr_t mapped_bno, struct xfs_buf **bpp);
-extern int xfs_dir3_data_readahead(struct xfs_trans *tp, struct xfs_inode *dp,
-                xfs_dablk_t bno, xfs_daddr_t mapped_bno);
+extern int xfs_dir3_data_readahead(struct xfs_inode *dp, xfs_dablk_t bno,
+                xfs_daddr_t mapped_bno);
 
 extern struct xfs_dir2_data_free *
 xfs_dir2_data_freeinsert(struct xfs_dir2_data_hdr *hdr,
diff --git a/fs/xfs/xfs_dir2_readdir.c b/fs/xfs/xfs_dir2_readdir.c
index aead369e1c30..50b72f7b8787 100644
--- a/fs/xfs/xfs_dir2_readdir.c
+++ b/fs/xfs/xfs_dir2_readdir.c
@@ -434,7 +434,7 @@ xfs_dir2_leaf_readbuf(
                  */
                 if (i > mip->ra_current &&
                     map[mip->ra_index].br_blockcount >= mp->m_dirblkfsbs) {
-                        xfs_dir3_data_readahead(NULL, dp,
+                        xfs_dir3_data_readahead(dp,
                                 map[mip->ra_index].br_startoff + mip->ra_offset,
                                 XFS_FSB_TO_DADDR(mp,
                                         map[mip->ra_index].br_startblock +
@@ -447,7 +447,7 @@ xfs_dir2_leaf_readbuf(
                  * use our mapping, but this is a very rare case.
                  */
                 else if (i > mip->ra_current) {
-                        xfs_dir3_data_readahead(NULL, dp,
+                        xfs_dir3_data_readahead(dp,
                                         map[mip->ra_index].br_startoff +
                                                         mip->ra_offset, -1);
                         mip->ra_current = i;
@@ -531,7 +531,7 @@ xfs_dir2_leaf_getdents(
          * Inside the loop we keep the main offset value as a byte offset
          * in the directory file.
          */
-        curoff = xfs_dir2_dataptr_to_byte(mp, ctx->pos);
+        curoff = xfs_dir2_dataptr_to_byte(ctx->pos);
 
         /*
          * Force this conversion through db so we truncate the offset
@@ -635,7 +635,7 @@ xfs_dir2_leaf_getdents(
                 length = dp->d_ops->data_entsize(dep->namelen);
                 filetype = dp->d_ops->data_get_ftype(dep);
 
-                ctx->pos = xfs_dir2_byte_to_dataptr(mp, curoff) & 0x7fffffff;
+                ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
                 if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
                             be64_to_cpu(dep->inumber),
                             xfs_dir3_get_dtype(mp, filetype)))
@@ -653,10 +653,10 @@ xfs_dir2_leaf_getdents(
         /*
          * All done.  Set output offset value to current offset.
          */
-        if (curoff > xfs_dir2_dataptr_to_byte(mp, XFS_DIR2_MAX_DATAPTR))
+        if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR))
                 ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
         else
-                ctx->pos = xfs_dir2_byte_to_dataptr(mp, curoff) & 0x7fffffff;
+                ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
         kmem_free(map_info);
         if (bp)
                 xfs_trans_brelse(NULL, bp);
@@ -687,7 +687,7 @@ xfs_readdir(
         lock_mode = xfs_ilock_data_map_shared(dp);
         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
                 rval = xfs_dir2_sf_getdents(dp, ctx);
-        else if ((rval = xfs_dir2_isblock(NULL, dp, &v)))
+        else if ((rval = xfs_dir2_isblock(dp, &v)))
                 ;
         else if (v)
                 rval = xfs_dir2_block_getdents(dp, ctx);
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index 3725fb1b902b..7aab8ec117ad 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -285,14 +285,12 @@ int						/* error */
 xfs_dir2_sf_addname(
         xfs_da_args_t           *args)          /* operation arguments */
 {
-        int                     add_entsize;    /* size of the new entry */
         xfs_inode_t             *dp;            /* incore directory inode */
         int                     error;          /* error return value */
         int                     incr_isize;     /* total change in size */
         int                     new_isize;      /* di_size after adding name */
         int                     objchange;      /* changing to 8-byte inodes */
         xfs_dir2_data_aoff_t    offset = 0;     /* offset for new entry */
-        int                     old_isize;      /* di_size before adding name */
         int                     pick;           /* which algorithm to use */
         xfs_dir2_sf_hdr_t       *sfp;           /* shortform structure */
         xfs_dir2_sf_entry_t     *sfep = NULL;   /* shortform entry */
@@ -316,8 +314,7 @@ xfs_dir2_sf_addname(
         /*
          * Compute entry (and change in) size.
          */
-        add_entsize = dp->d_ops->sf_entsize(sfp, args->namelen);
-        incr_isize = add_entsize;
+        incr_isize = dp->d_ops->sf_entsize(sfp, args->namelen);
         objchange = 0;
 #if XFS_BIG_INUMS
         /*
@@ -325,11 +322,8 @@ xfs_dir2_sf_addname(
          */
         if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && sfp->i8count == 0) {
                 /*
-                 * Yes, adjust the entry size and the total size.
+                 * Yes, adjust the inode size.  old count + (parent + new)
                  */
-                add_entsize +=
-                        (uint)sizeof(xfs_dir2_ino8_t) -
-                        (uint)sizeof(xfs_dir2_ino4_t);
                 incr_isize +=
                         (sfp->count + 2) *
                         ((uint)sizeof(xfs_dir2_ino8_t) -
@@ -337,8 +331,7 @@ xfs_dir2_sf_addname(
                 objchange = 1;
         }
 #endif
-        old_isize = (int)dp->i_d.di_size;
-        new_isize = old_isize + incr_isize;
+        new_isize = (int)dp->i_d.di_size + incr_isize;
         /*
          * Won't fit as shortform any more (due to size),
          * or the pick routine says it won't (due to offset values).
@@ -1110,9 +1103,9 @@ xfs_dir2_sf_toino4(
 }
 
 /*
- * Convert from 4-byte inode numbers to 8-byte inode numbers.
- * The new 8-byte inode number is not there yet, we leave with the
- * count 1 but no corresponding entry.
+ * Convert existing entries from 4-byte inode numbers to 8-byte inode numbers.
+ * The new entry w/ an 8-byte inode number is not there yet; we leave with
+ * i8count set to 1, but no corresponding 8-byte entry.
  */
 static void
 xfs_dir2_sf_toino8(
@@ -1145,7 +1138,7 @@ xfs_dir2_sf_toino8(
         ASSERT(oldsfp->i8count == 0);
         memcpy(buf, oldsfp, oldsize);
         /*
-         * Compute the new inode size.
+         * Compute the new inode size (nb: entry count + 1 for parent)
          */
         newsize =
                 oldsize +
diff --git a/fs/xfs/xfs_dquot_buf.c b/fs/xfs/xfs_dquot_buf.c
index 610da8177737..c2ac0c611ad8 100644
--- a/fs/xfs/xfs_dquot_buf.c
+++ b/fs/xfs/xfs_dquot_buf.c
@@ -35,7 +35,6 @@
 
 int
 xfs_calc_dquots_per_chunk(
-        struct xfs_mount        *mp,
         unsigned int            nbblks) /* basic block units */
 {
         unsigned int    ndquots;
@@ -194,7 +193,7 @@ xfs_dquot_buf_verify_crc(
         if (mp->m_quotainfo)
                 ndquots = mp->m_quotainfo->qi_dqperchunk;
         else
-                ndquots = xfs_calc_dquots_per_chunk(mp,
+                ndquots = xfs_calc_dquots_per_chunk(
                                         XFS_BB_TO_FSB(mp, bp->b_length));
 
         for (i = 0; i < ndquots; i++, d++) {
@@ -225,7 +224,7 @@ xfs_dquot_buf_verify(
         if (mp->m_quotainfo)
                 ndquots = mp->m_quotainfo->qi_dqperchunk;
         else
-                ndquots = xfs_calc_dquots_per_chunk(mp, bp->b_length);
+                ndquots = xfs_calc_dquots_per_chunk(bp->b_length);
 
         /*
          * On the first read of the buffer, verify that each dquot is valid.
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 830c1c937b88..1b8160dc04d1 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -944,7 +944,7 @@ xfs_dir_open(
          */
         mode = xfs_ilock_data_map_shared(ip);
         if (ip->i_d.di_nextents > 0)
-                xfs_dir3_data_readahead(NULL, ip, 0, -1);
+                xfs_dir3_data_readahead(ip, 0, -1);
         xfs_iunlock(ip, mode);
         return 0;
 }
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/xfs_ialloc_btree.c
index 7e309b11e87d..f1630ff619dd 100644
--- a/fs/xfs/xfs_ialloc_btree.c
+++ b/fs/xfs/xfs_ialloc_btree.c
@@ -71,7 +71,6 @@ xfs_inobt_alloc_block(
         struct xfs_btree_cur    *cur,
         union xfs_btree_ptr     *start,
         union xfs_btree_ptr     *new,
-        int                     length,
         int                     *stat)
 {
         xfs_alloc_arg_t         args;           /* block allocation args */
diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 98d35244eecc..c48df5f25b9f 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -507,8 +507,7 @@ STATIC int
 xfs_inode_ag_walk(
         struct xfs_mount        *mp,
         struct xfs_perag        *pag,
-        int                     (*execute)(struct xfs_inode *ip,
-                                           struct xfs_perag *pag, int flags,
+        int                     (*execute)(struct xfs_inode *ip, int flags,
                                            void *args),
         int                     flags,
         void                    *args,
@@ -582,7 +581,7 @@ restart:
                 for (i = 0; i < nr_found; i++) {
                         if (!batch[i])
                                 continue;
-                        error = execute(batch[i], pag, flags, args);
+                        error = execute(batch[i], flags, args);
                         IRELE(batch[i]);
                         if (error == EAGAIN) {
                                 skipped++;
@@ -636,8 +635,7 @@ xfs_eofblocks_worker(
 int
 xfs_inode_ag_iterator(
         struct xfs_mount        *mp,
-        int                     (*execute)(struct xfs_inode *ip,
-                                           struct xfs_perag *pag, int flags,
+        int                     (*execute)(struct xfs_inode *ip, int flags,
                                            void *args),
         int                     flags,
         void                    *args)
@@ -664,8 +662,7 @@ xfs_inode_ag_iterator(
 int
 xfs_inode_ag_iterator_tag(
         struct xfs_mount        *mp,
-        int                     (*execute)(struct xfs_inode *ip,
-                                           struct xfs_perag *pag, int flags,
+        int                     (*execute)(struct xfs_inode *ip, int flags,
                                            void *args),
         int                     flags,
         void                    *args,
@@ -1209,7 +1206,6 @@ xfs_inode_match_id(
 STATIC int
 xfs_inode_free_eofblocks(
         struct xfs_inode        *ip,
-        struct xfs_perag        *pag,
         int                     flags,
         void                    *args)
 {
diff --git a/fs/xfs/xfs_icache.h b/fs/xfs/xfs_icache.h
index 9ed68bb750f5..9cf017b899be 100644
--- a/fs/xfs/xfs_icache.h
+++ b/fs/xfs/xfs_icache.h
@@ -60,12 +60,10 @@ int xfs_icache_free_eofblocks(struct xfs_mount *, struct xfs_eofblocks *);
 void xfs_eofblocks_worker(struct work_struct *);
 
 int xfs_inode_ag_iterator(struct xfs_mount *mp,
-        int (*execute)(struct xfs_inode *ip, struct xfs_perag *pag,
-                int flags, void *args),
+        int (*execute)(struct xfs_inode *ip, int flags, void *args),
         int flags, void *args);
 int xfs_inode_ag_iterator_tag(struct xfs_mount *mp,
-        int (*execute)(struct xfs_inode *ip, struct xfs_perag *pag,
-                int flags, void *args),
+        int (*execute)(struct xfs_inode *ip, int flags, void *args),
         int flags, void *args, int tag);
 
 static inline int
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 768087bedbac..4e3b7ad7ac8f 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -3372,9 +3372,9 @@ xfs_iflush_int(
                 }
         }
 
-        xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK, bp);
+        xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
         if (XFS_IFORK_Q(ip))
-                xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK, bp);
+                xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
         xfs_inobp_check(mp, bp);
 
         /*
diff --git a/fs/xfs/xfs_inode_fork.c b/fs/xfs/xfs_inode_fork.c
index 73514c0486b7..b031e8d0d928 100644
--- a/fs/xfs/xfs_inode_fork.c
+++ b/fs/xfs/xfs_inode_fork.c
@@ -798,8 +798,7 @@ xfs_iflush_fork(
         xfs_inode_t             *ip,
         xfs_dinode_t            *dip,
         xfs_inode_log_item_t    *iip,
-        int                     whichfork,
-        xfs_buf_t               *bp)
+        int                     whichfork)
 {
         char                    *cp;
         xfs_ifork_t             *ifp;
diff --git a/fs/xfs/xfs_inode_fork.h b/fs/xfs/xfs_inode_fork.h
index eb329a1ea888..7d3b1ed6dcbe 100644
--- a/fs/xfs/xfs_inode_fork.h
+++ b/fs/xfs/xfs_inode_fork.h
@@ -127,8 +127,7 @@ typedef struct xfs_ifork {
 
 int             xfs_iformat_fork(struct xfs_inode *, struct xfs_dinode *);
 void            xfs_iflush_fork(struct xfs_inode *, struct xfs_dinode *,
-                                struct xfs_inode_log_item *, int,
-                                struct xfs_buf *);
+                                struct xfs_inode_log_item *, int);
 void            xfs_idestroy_fork(struct xfs_inode *, int);
 void            xfs_idata_realloc(struct xfs_inode *, int, int);
 void            xfs_iroot_realloc(struct xfs_inode *, int, int);
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 3b80ebae05f5..6c5eb4c551e3 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -730,7 +730,7 @@ xfs_iomap_write_allocate(
                          */
                         nimaps = 1;
                         end_fsb = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
-                        error = xfs_bmap_last_offset(NULL, ip, &last_block,
+                        error = xfs_bmap_last_offset(ip, &last_block,
                                                         XFS_DATA_FORK);
                         if (error)
                                 goto trans_cancel;
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index bce53ac81096..690a64d4444e 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -3145,7 +3145,7 @@ xlog_recover_efd_pass2(
                 }
                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
         }
-        xfs_trans_ail_cursor_done(ailp, &cur);
+        xfs_trans_ail_cursor_done(&cur);
         spin_unlock(&ailp->xa_lock);
 
         return 0;
@@ -3520,8 +3520,7 @@ out:
 
 STATIC int
 xlog_recover_unmount_trans(
-        struct xlog             *log,
-        struct xlog_recover     *trans)
+        struct xlog             *log)
 {
         /* Do nothing now */
         xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
@@ -3595,7 +3594,7 @@ xlog_recover_process_data(
                                                                 trans, pass);
                                 break;
                         case XLOG_UNMOUNT_TRANS:
-                                error = xlog_recover_unmount_trans(log, trans);
+                                error = xlog_recover_unmount_trans(log);
                                 break;
                         case XLOG_WAS_CONT_TRANS:
                                 error = xlog_recover_add_to_cont_trans(log,
@@ -3757,7 +3756,7 @@ xlog_recover_process_efis(
                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
         }
 out:
-        xfs_trans_ail_cursor_done(ailp, &cur);
+        xfs_trans_ail_cursor_done(&cur);
         spin_unlock(&ailp->xa_lock);
         return error;
 }
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index dc977b6e6a36..061fad7ca820 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -865,8 +865,7 @@ xfs_qm_init_quotainfo(
 
         /* Precalc some constants */
         qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
-        qinf->qi_dqperchunk = xfs_calc_dquots_per_chunk(mp,
-                                                        qinf->qi_dqchunklen);
+        qinf->qi_dqperchunk = xfs_calc_dquots_per_chunk(qinf->qi_dqchunklen);
 
         mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
 
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 3daf5ea1eb8d..72cbe65e5e75 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -959,7 +959,6 @@ xfs_qm_export_flags(
 STATIC int
 xfs_dqrele_inode(
         struct xfs_inode        *ip,
-        struct xfs_perag        *pag,
         int                     flags,
         void                    *args)
 {
diff --git a/fs/xfs/xfs_quota_defs.h b/fs/xfs/xfs_quota_defs.h
index b3b2b1065c0f..137e20937077 100644
--- a/fs/xfs/xfs_quota_defs.h
+++ b/fs/xfs/xfs_quota_defs.h
@@ -156,6 +156,6 @@ typedef __uint16_t	xfs_qwarncnt_t;
 
 extern int xfs_dqcheck(struct xfs_mount *mp, xfs_disk_dquot_t *ddq,
                        xfs_dqid_t id, uint type, uint flags, char *str);
-extern int xfs_calc_dquots_per_chunk(struct xfs_mount *mp, unsigned int nbblks);
+extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
 
 #endif  /* __XFS_QUOTA_H__ */
diff --git a/fs/xfs/xfs_shared.h b/fs/xfs/xfs_shared.h
index 4484e5151395..82404da2ca67 100644
--- a/fs/xfs/xfs_shared.h
+++ b/fs/xfs/xfs_shared.h
@@ -238,7 +238,7 @@ int	xfs_log_calc_minimum_size(struct xfs_mount *);
 int xfs_symlink_blocks(struct xfs_mount *mp, int pathlen);
 int xfs_symlink_hdr_set(struct xfs_mount *mp, xfs_ino_t ino, uint32_t offset,
                         uint32_t size, struct xfs_buf *bp);
-bool xfs_symlink_hdr_ok(struct xfs_mount *mp, xfs_ino_t ino, uint32_t offset,
+bool xfs_symlink_hdr_ok(xfs_ino_t ino, uint32_t offset,
                         uint32_t size, struct xfs_buf *bp);
 void xfs_symlink_local_to_remote(struct xfs_trans *tp, struct xfs_buf *bp,
                                  struct xfs_inode *ip, struct xfs_ifork *ifp);
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 3494eff8e4eb..6e6673543777 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -765,20 +765,18 @@ xfs_open_devices(
          * Setup xfs_mount buffer target pointers
          */
         error = ENOMEM;
-        mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev, 0, mp->m_fsname);
+        mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev);
         if (!mp->m_ddev_targp)
                 goto out_close_rtdev;
 
         if (rtdev) {
-                mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev, 1,
-                                                        mp->m_fsname);
+                mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev);
                 if (!mp->m_rtdev_targp)
                         goto out_free_ddev_targ;
         }
 
         if (logdev && logdev != ddev) {
-                mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev, 1,
-                                                        mp->m_fsname);
+                mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev);
                 if (!mp->m_logdev_targp)
                         goto out_free_rtdev_targ;
         } else {
@@ -811,8 +809,7 @@ xfs_setup_devices(
 {
         int                     error;
 
-        error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_blocksize,
-                                    mp->m_sb.sb_sectsize);
+        error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_sectsize);
         if (error)
                 return error;
 
@@ -822,14 +819,12 @@ xfs_setup_devices(
                 if (xfs_sb_version_hassector(&mp->m_sb))
                         log_sector_size = mp->m_sb.sb_logsectsize;
                 error = xfs_setsize_buftarg(mp->m_logdev_targp,
-                                            mp->m_sb.sb_blocksize,
                                             log_sector_size);
                 if (error)
                         return error;
         }
         if (mp->m_rtdev_targp) {
                 error = xfs_setsize_buftarg(mp->m_rtdev_targp,
-                                            mp->m_sb.sb_blocksize,
                                             mp->m_sb.sb_sectsize);
                 if (error)
                         return error;
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index 52979aa90986..0816b4018dfc 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -92,7 +92,7 @@ xfs_readlink_bmap(
 
                 cur_chunk = bp->b_addr;
                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
-                        if (!xfs_symlink_hdr_ok(mp, ip->i_ino, offset,
+                        if (!xfs_symlink_hdr_ok(ip->i_ino, offset,
                                                         byte_cnt, bp)) {
                                 error = EFSCORRUPTED;
                                 xfs_alert(mp,
diff --git a/fs/xfs/xfs_symlink_remote.c b/fs/xfs/xfs_symlink_remote.c
index 9b32052ff65e..23c2f2577c8d 100644
--- a/fs/xfs/xfs_symlink_remote.c
+++ b/fs/xfs/xfs_symlink_remote.c
@@ -80,7 +80,6 @@ xfs_symlink_hdr_set(
  */
 bool
 xfs_symlink_hdr_ok(
-        struct xfs_mount        *mp,
         xfs_ino_t               ino,
         uint32_t                offset,
         uint32_t                size,
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 54a57326d85b..d03932564ccb 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -827,7 +827,7 @@ xfs_trans_committed_bulk(
                 xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
 
         spin_lock(&ailp->xa_lock);
-        xfs_trans_ail_cursor_done(ailp, &cur);
+        xfs_trans_ail_cursor_done(&cur);
         spin_unlock(&ailp->xa_lock);
 }
 
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index a7287354e535..cb0f3a84cc68 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -173,7 +173,6 @@ xfs_trans_ail_cursor_next(
  */
 void
 xfs_trans_ail_cursor_done(
-        struct xfs_ail          *ailp,
         struct xfs_ail_cursor   *cur)
 {
         cur->item = NULL;
@@ -368,7 +367,7 @@ xfsaild_push(
                  * If the AIL is empty or our push has reached the end we are
                  * done now.
                  */
-                xfs_trans_ail_cursor_done(ailp, &cur);
+                xfs_trans_ail_cursor_done(&cur);
                 spin_unlock(&ailp->xa_lock);
                 goto out_done;
         }
@@ -453,7 +452,7 @@ xfsaild_push(
                         break;
                 lsn = lip->li_lsn;
         }
-        xfs_trans_ail_cursor_done(ailp, &cur);
+        xfs_trans_ail_cursor_done(&cur);
         spin_unlock(&ailp->xa_lock);
 
         if (xfs_buf_delwri_submit_nowait(&ailp->xa_buf_list))
diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h
index 12e86af9d9b9..bd1281862ad7 100644
--- a/fs/xfs/xfs_trans_priv.h
+++ b/fs/xfs/xfs_trans_priv.h
@@ -133,8 +133,7 @@ struct xfs_log_item *	xfs_trans_ail_cursor_last(struct xfs_ail *ailp,
                                         xfs_lsn_t lsn);
 struct xfs_log_item *   xfs_trans_ail_cursor_next(struct xfs_ail *ailp,
                                         struct xfs_ail_cursor *cur);
-void                    xfs_trans_ail_cursor_done(struct xfs_ail *ailp,
-                                        struct xfs_ail_cursor *cur);
+void                    xfs_trans_ail_cursor_done(struct xfs_ail_cursor *cur);
 
 #if BITS_PER_LONG != 64
 static inline void