struct xfs_trans        *tp = NULL;
        int                     error;
        struct xfs_defer_ops    dfops;
-       xfs_fsblock_t           first_block;
        bool                    unlock_dp_on_error = false;
        prid_t                  prid;
        struct xfs_dquot        *udqp = NULL;
        xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
        unlock_dp_on_error = true;
 
-       xfs_defer_init(tp, &dfops, &first_block);
+       xfs_defer_init(tp, &dfops, &tp->t_firstblock);
 
        /*
         * Reserve disk quota and the inode.
        xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
        unlock_dp_on_error = false;
 
-       error = xfs_dir_createname(tp, dp, name, ip->i_ino, &first_block,
+       error = xfs_dir_createname(tp, dp, name, ip->i_ino, &tp->t_firstblock,
                                   resblks ?
                                        resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
        if (error) {
        xfs_trans_t             *tp;
        int                     error;
        struct xfs_defer_ops    dfops;
-       xfs_fsblock_t           first_block;
        int                     resblks;
 
        trace_xfs_link(tdp, target_name);
                        goto error_return;
        }
 
-       xfs_defer_init(tp, &dfops, &first_block);
+       xfs_defer_init(tp, &dfops, &tp->t_firstblock);
 
        /*
         * Handle initial link state of O_TMPFILE inode
        }
 
        error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
-                                  &first_block, resblks);
+                                  &tp->t_firstblock, resblks);
        if (error)
                goto error_return;
        xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
        int                     is_dir = S_ISDIR(VFS_I(ip)->i_mode);
        int                     error = 0;
        struct xfs_defer_ops    dfops;
-       xfs_fsblock_t           first_block;
        uint                    resblks;
 
        trace_xfs_remove(dp, name);
        if (error)
                goto out_trans_cancel;
 
-       xfs_defer_init(tp, &dfops, &first_block);
-       error = xfs_dir_removename(tp, dp, name, ip->i_ino, &first_block,
+       xfs_defer_init(tp, &dfops, &tp->t_firstblock);
+       error = xfs_dir_removename(tp, dp, name, ip->i_ino, &tp->t_firstblock,
                                   resblks);
        if (error) {
                ASSERT(error != -ENOENT);
        struct xfs_inode        *dp2,
        struct xfs_name         *name2,
        struct xfs_inode        *ip2,
-       xfs_fsblock_t           *first_block,
        int                     spaceres)
 {
        int             error = 0;
        int             dp2_flags = 0;
 
        /* Swap inode number for dirent in first parent */
-       error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, first_block,
+       error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, &tp->t_firstblock,
                                spaceres);
        if (error)
                goto out_trans_abort;
 
        /* Swap inode number for dirent in second parent */
-       error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, first_block,
+       error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, &tp->t_firstblock,
                                spaceres);
        if (error)
                goto out_trans_abort;
 
                if (S_ISDIR(VFS_I(ip2)->i_mode)) {
                        error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
-                                               dp1->i_ino, first_block,
+                                               dp1->i_ino, &tp->t_firstblock,
                                                spaceres);
                        if (error)
                                goto out_trans_abort;
 
                if (S_ISDIR(VFS_I(ip1)->i_mode)) {
                        error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
-                                               dp2->i_ino, first_block,
+                                               dp2->i_ino, &tp->t_firstblock,
                                                spaceres);
                        if (error)
                                goto out_trans_abort;
        struct xfs_mount        *mp = src_dp->i_mount;
        struct xfs_trans        *tp;
        struct xfs_defer_ops    dfops;
-       xfs_fsblock_t           first_block;
        struct xfs_inode        *wip = NULL;            /* whiteout inode */
        struct xfs_inode        *inodes[__XFS_SORT_INODES];
        int                     num_inodes = __XFS_SORT_INODES;
                goto out_trans_cancel;
        }
 
-       xfs_defer_init(tp, &dfops, &first_block);
+       xfs_defer_init(tp, &dfops, &tp->t_firstblock);
 
        /* RENAME_EXCHANGE is unique from here on. */
        if (flags & RENAME_EXCHANGE)
                return xfs_cross_rename(tp, src_dp, src_name, src_ip,
                                        target_dp, target_name, target_ip,
-                                       &first_block, spaceres);
+                                       spaceres);
 
        /*
         * Set up the target.
                 * to account for the ".." reference from the new entry.
                 */
                error = xfs_dir_createname(tp, target_dp, target_name,
-                                               src_ip->i_ino, &first_block,
-                                               spaceres);
+                                          src_ip->i_ino, &tp->t_firstblock,
+                                          spaceres);
                if (error)
                        goto out_bmap_cancel;
 
                 * name at the destination directory, remove it first.
                 */
                error = xfs_dir_replace(tp, target_dp, target_name,
-                                       src_ip->i_ino, &first_block, spaceres);
+                                       src_ip->i_ino, &tp->t_firstblock,
+                                       spaceres);
                if (error)
                        goto out_bmap_cancel;
 
                 * directory.
                 */
                error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
-                                       target_dp->i_ino, &first_block,
+                                       target_dp->i_ino, &tp->t_firstblock,
                                        spaceres);
                ASSERT(error != -EEXIST);
                if (error)
         */
        if (wip) {
                error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
-                                       &first_block, spaceres);
+                                       &tp->t_firstblock, spaceres);
        } else
                error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
-                                          &first_block, spaceres);
+                                          &tp->t_firstblock, spaceres);
        if (error)
                goto out_bmap_cancel;
 
 
        int                     error = 0;
        int                     pathlen;
        struct xfs_defer_ops    dfops;
-       xfs_fsblock_t           first_block;
        bool                    unlock_dp_on_error = false;
        xfs_fileoff_t           first_fsb;
        xfs_filblks_t           fs_blocks;
         * Initialize the bmap freelist prior to calling either
         * bmapi or the directory create code.
         */
-       xfs_defer_init(tp, &dfops, &first_block);
+       xfs_defer_init(tp, &dfops, &tp->t_firstblock);
 
        /*
         * Allocate an inode for the symlink.
                nmaps = XFS_SYMLINK_MAPS;
 
                error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
-                                 XFS_BMAPI_METADATA, &first_block, resblks,
-                                 mval, &nmaps);
+                                 XFS_BMAPI_METADATA, &tp->t_firstblock,
+                                 resblks, mval, &nmaps);
                if (error)
                        goto out_bmap_cancel;
 
         * Create the directory entry for the symlink.
         */
        error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
-                                  &first_block, resblks);
+                                  &tp->t_firstblock, resblks);
        if (error)
                goto out_bmap_cancel;
        xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);