1 files changed, 96 insertions, 1 deletions

diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index f264616080ca..01f6a646caa1 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -1349,7 +1349,6 @@ xfs_free_file_space(
                  * the freeing of the space succeeds at ENOSPC.
                  */
                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
-                tp->t_flags |= XFS_TRANS_RESERVE;
                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write, resblks, 0);
 
                 /*
@@ -1468,6 +1467,102 @@ out:
 }
 
 /*
+ * xfs_collapse_file_space()
+ *      This routine frees disk space and shift extent for the given file.
+ *      The first thing we do is to free data blocks in the specified range
+ *      by calling xfs_free_file_space(). It would also sync dirty data
+ *      and invalidate page cache over the region on which collapse range
+ *      is working. And Shift extent records to the left to cover a hole.
+ * RETURNS:
+ *      0 on success
+ *      errno on error
+ *
+ */
+int
+xfs_collapse_file_space(
+        struct xfs_inode        *ip,
+        xfs_off_t               offset,
+        xfs_off_t               len)
+{
+        int                     done = 0;
+        struct xfs_mount        *mp = ip->i_mount;
+        struct xfs_trans        *tp;
+        int                     error;
+        xfs_extnum_t            current_ext = 0;
+        struct xfs_bmap_free    free_list;
+        xfs_fsblock_t           first_block;
+        int                     committed;
+        xfs_fileoff_t           start_fsb;
+        xfs_fileoff_t           shift_fsb;
+
+        ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
+
+        trace_xfs_collapse_file_space(ip);
+
+        start_fsb = XFS_B_TO_FSB(mp, offset + len);
+        shift_fsb = XFS_B_TO_FSB(mp, len);
+
+        error = xfs_free_file_space(ip, offset, len);
+        if (error)
+                return error;
+
+        while (!error && !done) {
+                tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
+                tp->t_flags |= XFS_TRANS_RESERVE;
+                /*
+                 * We would need to reserve permanent block for transaction.
+                 * This will come into picture when after shifting extent into
+                 * hole we found that adjacent extents can be merged which
+                 * may lead to freeing of a block during record update.
+                 */
+                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
+                                XFS_DIOSTRAT_SPACE_RES(mp, 0), 0);
+                if (error) {
+                        ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
+                        xfs_trans_cancel(tp, 0);
+                        break;
+                }
+
+                xfs_ilock(ip, XFS_ILOCK_EXCL);
+                error = xfs_trans_reserve_quota(tp, mp, ip->i_udquot,
+                                ip->i_gdquot, ip->i_pdquot,
+                                XFS_DIOSTRAT_SPACE_RES(mp, 0), 0,
+                                XFS_QMOPT_RES_REGBLKS);
+                if (error)
+                        goto out;
+
+                xfs_trans_ijoin(tp, ip, 0);
+
+                xfs_bmap_init(&free_list, &first_block);
+
+                /*
+                 * We are using the write transaction in which max 2 bmbt
+                 * updates are allowed
+                 */
+                error = xfs_bmap_shift_extents(tp, ip, &done, start_fsb,
+                                               shift_fsb, &current_ext,
+                                               &first_block, &free_list,
+                                               XFS_BMAP_MAX_SHIFT_EXTENTS);
+                if (error)
+                        goto out;
+
+                error = xfs_bmap_finish(&tp, &free_list, &committed);
+                if (error)
+                        goto out;
+
+                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        }
+
+        return error;
+
+out:
+        xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        return error;
+}
+
+/*
  * We need to check that the format of the data fork in the temporary inode is
  * valid for the target inode before doing the swap. This is not a problem with
  * attr1 because of the fixed fork offset, but attr2 has a dynamically sized