--- initial
+++ final
@@ -1,92 +1,92 @@
 int xfs_reflink_end_cow(struct xfs_inode *ip, xfs_off_t offset, xfs_off_t count) {
   struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
   struct xfs_bmbt_irec got, del;
   struct xfs_trans *tp;
   xfs_fileoff_t offset_fsb;
   xfs_fileoff_t end_fsb;
   struct xfs_defer_ops dfops;
   int error;
   unsigned int resblks;
   xfs_filblks_t rlen;
   struct xfs_iext_cursor icur;
   trace_xfs_reflink_end_cow(ip, offset, count);
   /* No COW extents?  That's easy! */
   if (ifp->if_bytes == 0) return 0;
   offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
   end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
   /*
    * Start a rolling transaction to switch the mappings.  We're
    * unlikely ever to have to remap 16T worth of single-block
    * extents, so just cap the worst case extent count to 2^32-1.
    * Stick a warning in just in case, and avoid 64-bit division.
    */
   BUILD_BUG_ON(MAX_RW_COUNT > UINT_MAX);
   if (end_fsb - offset_fsb > UINT_MAX) {
     error = -EFSCORRUPTED;
     xfs_force_shutdown(ip->i_mount, SHUTDOWN_CORRUPT_INCORE);
     ASSERT(0);
     goto out;
   }
   resblks = XFS_NEXTENTADD_SPACE_RES(ip->i_mount, (unsigned int)(end_fsb - offset_fsb), XFS_DATA_FORK);
   error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write, resblks, 0, XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
   if (error) goto out;
   xfs_ilock(ip, XFS_ILOCK_EXCL);
   xfs_trans_ijoin(tp, ip, 0);
   /*
    * In case of racing, overlapping AIO writes no COW extents might be
    * left by the time I/O completes for the loser of the race.  In that
    * case we are done.
    */
   if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got)) goto out_cancel;
   /* Walk backwards until we're out of the I/O range... */
   while (got.br_startoff + got.br_blockcount > offset_fsb) {
     del = got;
     xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
     /* Extent delete may have bumped ext forward */
     if (!del.br_blockcount) goto prev_extent;
     ASSERT(!isnullstartblock(got.br_startblock));
     /*
      * Don't remap unwritten extents; these are
      * speculatively preallocated CoW extents that have been
      * allocated but have not yet been involved in a write.
      */
     if (got.br_state == XFS_EXT_UNWRITTEN) goto prev_extent;
     /* Unmap the old blocks in the data fork. */
-    xfs_defer_init(tp, &dfops, &tp->t_firstblock);
+    xfs_defer_init(tp, &dfops);
     rlen = del.br_blockcount;
     error = __xfs_bunmapi(tp, ip, del.br_startoff, &rlen, 0, 1);
     if (error) goto out_defer;
     /* Trim the extent to whatever got unmapped. */
     if (rlen) { xfs_trim_extent(&del, del.br_startoff + rlen, del.br_blockcount - rlen); }
     trace_xfs_reflink_cow_remap(ip, &del);
     /* Free the CoW orphan record. */
     error = xfs_refcount_free_cow_extent(tp->t_mountp, tp->t_dfops, del.br_startblock, del.br_blockcount);
     if (error) goto out_defer;
     /* Map the new blocks into the data fork. */
     error = xfs_bmap_map_extent(tp->t_mountp, tp->t_dfops, ip, &del);
     if (error) goto out_defer;
     /* Charge this new data fork mapping to the on-disk quota. */
     xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_DELBCOUNT, (long)del.br_blockcount);
     /* Remove the mapping from the CoW fork. */
     xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
     xfs_defer_ijoin(tp->t_dfops, ip);
     error = xfs_defer_finish(&tp, tp->t_dfops);
     if (error) goto out_defer;
     if (!xfs_iext_get_extent(ifp, &icur, &got)) break;
     continue;
   prev_extent:
     if (!xfs_iext_prev_extent(ifp, &icur, &got)) break;
   }
   error = xfs_trans_commit(tp);
   xfs_iunlock(ip, XFS_ILOCK_EXCL);
   if (error) goto out;
   return 0;
 out_defer:
   xfs_defer_cancel(tp->t_dfops);
 out_cancel:
   xfs_trans_cancel(tp);
   xfs_iunlock(ip, XFS_ILOCK_EXCL);
 out:
   trace_xfs_reflink_end_cow_error(ip, error, _RET_IP_);
   return error;
 }<sep>@@
expression e1,e2,e3;
@@
  xfs_defer_init(e1,e2
- 		, e3
	)