Merge tag 'iommu-updates-v5.19' of git://git.kernel.org/pub/scm/linux/kernel/git...

[linux-2.6-microblaze.git] / fs / xfs / xfs_iomap.c

diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index e552ce5..5a39325 100644 (file)
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -251,6 +251,8 @@ xfs_iomap_write_direct(
                return error;
 
        error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, nr_exts);
+       if (error == -EFBIG)
+               error = xfs_iext_count_upgrade(tp, ip, nr_exts);
        if (error)
                goto out_trans_cancel;
 
@@ -402,7 +404,7 @@ xfs_iomap_prealloc_size(
         */
        plen = prev.br_blockcount;
        while (xfs_iext_prev_extent(ifp, &ncur, &got)) {
-               if (plen > MAXEXTLEN / 2 ||
+               if (plen > XFS_MAX_BMBT_EXTLEN / 2 ||
                    isnullstartblock(got.br_startblock) ||
                    got.br_startoff + got.br_blockcount != prev.br_startoff ||
                    got.br_startblock + got.br_blockcount != prev.br_startblock)
@@ -414,23 +416,23 @@ xfs_iomap_prealloc_size(
        /*
         * If the size of the extents is greater than half the maximum extent
         * length, then use the current offset as the basis.  This ensures that
-        * for large files the preallocation size always extends to MAXEXTLEN
-        * rather than falling short due to things like stripe unit/width
-        * alignment of real extents.
+        * for large files the preallocation size always extends to
+        * XFS_BMBT_MAX_EXTLEN rather than falling short due to things like stripe
+        * unit/width alignment of real extents.
         */
        alloc_blocks = plen * 2;
-       if (alloc_blocks > MAXEXTLEN)
+       if (alloc_blocks > XFS_MAX_BMBT_EXTLEN)
                alloc_blocks = XFS_B_TO_FSB(mp, offset);
        qblocks = alloc_blocks;
 
        /*
-        * MAXEXTLEN is not a power of two value but we round the prealloc down
-        * to the nearest power of two value after throttling. To prevent the
-        * round down from unconditionally reducing the maximum supported
-        * prealloc size, we round up first, apply appropriate throttling,
-        * round down and cap the value to MAXEXTLEN.
+        * XFS_BMBT_MAX_EXTLEN is not a power of two value but we round the prealloc
+        * down to the nearest power of two value after throttling. To prevent
+        * the round down from unconditionally reducing the maximum supported
+        * prealloc size, we round up first, apply appropriate throttling, round
+        * down and cap the value to XFS_BMBT_MAX_EXTLEN.
         */
-       alloc_blocks = XFS_FILEOFF_MIN(roundup_pow_of_two(MAXEXTLEN),
+       alloc_blocks = XFS_FILEOFF_MIN(roundup_pow_of_two(XFS_MAX_BMBT_EXTLEN),
                                       alloc_blocks);
 
        freesp = percpu_counter_read_positive(&mp->m_fdblocks);
@@ -478,14 +480,14 @@ xfs_iomap_prealloc_size(
         */
        if (alloc_blocks)
                alloc_blocks = rounddown_pow_of_two(alloc_blocks);
-       if (alloc_blocks > MAXEXTLEN)
-               alloc_blocks = MAXEXTLEN;
+       if (alloc_blocks > XFS_MAX_BMBT_EXTLEN)
+               alloc_blocks = XFS_MAX_BMBT_EXTLEN;
 
        /*
         * If we are still trying to allocate more space than is
         * available, squash the prealloc hard. This can happen if we
         * have a large file on a small filesystem and the above
-        * lowspace thresholds are smaller than MAXEXTLEN.
+        * lowspace thresholds are smaller than XFS_BMBT_MAX_EXTLEN.
         */
        while (alloc_blocks && alloc_blocks >= freesp)
                alloc_blocks >>= 4;
@@ -555,6 +557,9 @@ xfs_iomap_write_unwritten(
 
                error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
                                XFS_IEXT_WRITE_UNWRITTEN_CNT);
+               if (error == -EFBIG)
+                       error = xfs_iext_count_upgrade(tp, ip,
+                                       XFS_IEXT_WRITE_UNWRITTEN_CNT);
                if (error)
                        goto error_on_bmapi_transaction;