Re: [PATCH V5 16/16] xfs: Define max extent length based on on-disk format definition

Darrick J. Wong
2022-02-01T19:26:45Z

On Fri, Jan 21, 2022 at 10:48:57AM +0530, Chandan Babu R wrote:
> The maximum extent length depends on maximum block count that can be stored in
> a BMBT record. Hence this commit defines MAXEXTLEN based on
> BMBT_BLOCKCOUNT_BITLEN.
>
> While at it, the commit also renames MAXEXTLEN to XFS_MAX_BMBT_EXTLEN.
>
> Suggested-by: Darrick J. Wong <djwong@kernel.org>
> Signed-off-by: Chandan Babu R <chandan.babu@oracle.com>

Looks good now,
Reviewed-by: Darrick J. Wong <djwong@kernel.org>

--D

> ---
> fs/xfs/libxfs/xfs_alloc.c | 2 +-
> fs/xfs/libxfs/xfs_bmap.c | 57 +++++++++++++++++-----------------
> fs/xfs/libxfs/xfs_format.h | 5 +--
> fs/xfs/libxfs/xfs_inode_buf.c | 4 +--
> fs/xfs/libxfs/xfs_trans_resv.c | 11 ++++---
> fs/xfs/scrub/bmap.c | 2 +-
> fs/xfs/xfs_bmap_util.c | 14 +++++----
> fs/xfs/xfs_iomap.c | 28 ++++++++---------
> 8 files changed, 64 insertions(+), 59 deletions(-)
>
> diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
> index 353e53b892e6..3f9b9cbfef43 100644
> --- a/fs/xfs/libxfs/xfs_alloc.c
> +++ b/fs/xfs/libxfs/xfs_alloc.c
> @@ -2493,7 +2493,7 @@ __xfs_free_extent_later(
>
> ASSERT(bno != NULLFSBLOCK);
> ASSERT(len > 0);
> - ASSERT(len <= MAXEXTLEN);
> + ASSERT(len <= XFS_MAX_BMBT_EXTLEN);
> ASSERT(!isnullstartblock(bno));
> agno = XFS_FSB_TO_AGNO(mp, bno);
> agbno = XFS_FSB_TO_AGBNO(mp, bno);
> diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
> index 384532aac60a..1c3da6aac2f9 100644
> --- a/fs/xfs/libxfs/xfs_bmap.c
> +++ b/fs/xfs/libxfs/xfs_bmap.c
> @@ -1449,7 +1449,7 @@ xfs_bmap_add_extent_delay_real(
> LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
> LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
> LEFT.br_state == new->br_state &&
> - LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN)
> + LEFT.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
> state |= BMAP_LEFT_CONTIG;
>
> /*
> @@ -1467,13 +1467,13 @@ xfs_bmap_add_extent_delay_real(
> new_endoff == RIGHT.br_startoff &&
> new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
> new->br_state == RIGHT.br_state &&
> - new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN &&
> + new->br_blockcount + RIGHT.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
> ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
> BMAP_RIGHT_FILLING)) !=
> (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
> BMAP_RIGHT_FILLING) ||
> LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
> - <= MAXEXTLEN))
> + <= XFS_MAX_BMBT_EXTLEN))
> state |= BMAP_RIGHT_CONTIG;
>
> error = 0;
> @@ -1997,7 +1997,7 @@ xfs_bmap_add_extent_unwritten_real(
> LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
> LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
> LEFT.br_state == new->br_state &&
> - LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN)
> + LEFT.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
> state |= BMAP_LEFT_CONTIG;
>
> /*
> @@ -2015,13 +2015,13 @@ xfs_bmap_add_extent_unwritten_real(
> new_endoff == RIGHT.br_startoff &&
> new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
> new->br_state == RIGHT.br_state &&
> - new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN &&
> + new->br_blockcount + RIGHT.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
> ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
> BMAP_RIGHT_FILLING)) !=
> (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
> BMAP_RIGHT_FILLING) ||
> LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
> - <= MAXEXTLEN))
> + <= XFS_MAX_BMBT_EXTLEN))
> state |= BMAP_RIGHT_CONTIG;
>
> /*
> @@ -2507,15 +2507,15 @@ xfs_bmap_add_extent_hole_delay(
> */
> if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) &&
> left.br_startoff + left.br_blockcount == new->br_startoff &&
> - left.br_blockcount + new->br_blockcount <= MAXEXTLEN)
> + left.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
> state |= BMAP_LEFT_CONTIG;
>
> if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) &&
> new->br_startoff + new->br_blockcount == right.br_startoff &&
> - new->br_blockcount + right.br_blockcount <= MAXEXTLEN &&
> + new->br_blockcount + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
> (!(state & BMAP_LEFT_CONTIG) ||
> (left.br_blockcount + new->br_blockcount +
> - right.br_blockcount <= MAXEXTLEN)))
> + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN)))
> state |= BMAP_RIGHT_CONTIG;
>
> /*
> @@ -2658,17 +2658,17 @@ xfs_bmap_add_extent_hole_real(
> left.br_startoff + left.br_blockcount == new->br_startoff &&
> left.br_startblock + left.br_blockcount == new->br_startblock &&
> left.br_state == new->br_state &&
> - left.br_blockcount + new->br_blockcount <= MAXEXTLEN)
> + left.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
> state |= BMAP_LEFT_CONTIG;
>
> if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
> new->br_startoff + new->br_blockcount == right.br_startoff &&
> new->br_startblock + new->br_blockcount == right.br_startblock &&
> new->br_state == right.br_state &&
> - new->br_blockcount + right.br_blockcount <= MAXEXTLEN &&
> + new->br_blockcount + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
> (!(state & BMAP_LEFT_CONTIG) ||
> left.br_blockcount + new->br_blockcount +
> - right.br_blockcount <= MAXEXTLEN))
> + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN))
> state |= BMAP_RIGHT_CONTIG;
>
> error = 0;
> @@ -2903,15 +2903,15 @@ xfs_bmap_extsize_align(
>
> /*
> * For large extent hint sizes, the aligned extent might be larger than
> - * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls
> - * the length back under MAXEXTLEN. The outer allocation loops handle
> - * short allocation just fine, so it is safe to do this. We only want to
> - * do it when we are forced to, though, because it means more allocation
> - * operations are required.
> + * XFS_BMBT_MAX_EXTLEN. In that case, reduce the size by an extsz so
> + * that it pulls the length back under XFS_BMBT_MAX_EXTLEN. The outer
> + * allocation loops handle short allocation just fine, so it is safe to
> + * do this. We only want to do it when we are forced to, though, because
> + * it means more allocation operations are required.
> */
> - while (align_alen > MAXEXTLEN)
> + while (align_alen > XFS_MAX_BMBT_EXTLEN)
> align_alen -= extsz;
> - ASSERT(align_alen <= MAXEXTLEN);
> + ASSERT(align_alen <= XFS_MAX_BMBT_EXTLEN);
>
> /*
> * If the previous block overlaps with this proposed allocation
> @@ -3001,9 +3001,9 @@ xfs_bmap_extsize_align(
> return -EINVAL;
> } else {
> ASSERT(orig_off >= align_off);
> - /* see MAXEXTLEN handling above */
> + /* see XFS_BMBT_MAX_EXTLEN handling above */
> ASSERT(orig_end <= align_off + align_alen ||
> - align_alen + extsz > MAXEXTLEN);
> + align_alen + extsz > XFS_MAX_BMBT_EXTLEN);
> }
>
> #ifdef DEBUG
> @@ -3968,7 +3968,7 @@ xfs_bmapi_reserve_delalloc(
> * Cap the alloc length. Keep track of prealloc so we know whether to
> * tag the inode before we return.
> */
> - alen = XFS_FILBLKS_MIN(len + prealloc, MAXEXTLEN);
> + alen = XFS_FILBLKS_MIN(len + prealloc, XFS_MAX_BMBT_EXTLEN);
> if (!eof)
> alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff);
> if (prealloc && alen >= len)
> @@ -4101,7 +4101,7 @@ xfs_bmapi_allocate(
> if (!xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev))
> bma->prev.br_startoff = NULLFILEOFF;
> } else {
> - bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN);
> + bma->length = XFS_FILBLKS_MIN(bma->length, XFS_MAX_BMBT_EXTLEN);
> if (!bma->eof)
> bma->length = XFS_FILBLKS_MIN(bma->length,
> bma->got.br_startoff - bma->offset);
> @@ -4421,8 +4421,8 @@ xfs_bmapi_write(
> * xfs_extlen_t and therefore 32 bits. Hence we have to
> * check for 32-bit overflows and handle them here.
> */
> - if (len > (xfs_filblks_t)MAXEXTLEN)
> - bma.length = MAXEXTLEN;
> + if (len > (xfs_filblks_t)XFS_MAX_BMBT_EXTLEN)
> + bma.length = XFS_MAX_BMBT_EXTLEN;
> else
> bma.length = len;
>
> @@ -4557,7 +4557,8 @@ xfs_bmapi_convert_delalloc(
> bma.ip = ip;
> bma.wasdel = true;
> bma.offset = bma.got.br_startoff;
> - bma.length = max_t(xfs_filblks_t, bma.got.br_blockcount, MAXEXTLEN);
> + bma.length = max_t(xfs_filblks_t, bma.got.br_blockcount,
> + XFS_MAX_BMBT_EXTLEN);
> bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
>
> /*
> @@ -4638,7 +4639,7 @@ xfs_bmapi_remap(
>
> ifp = XFS_IFORK_PTR(ip, whichfork);
> ASSERT(len > 0);
> - ASSERT(len <= (xfs_filblks_t)MAXEXTLEN);
> + ASSERT(len <= (xfs_filblks_t)XFS_MAX_BMBT_EXTLEN);
> ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
> ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC |
> XFS_BMAPI_NORMAP)));
> @@ -5638,7 +5639,7 @@ xfs_bmse_can_merge(
> if ((left->br_startoff + left->br_blockcount != startoff) ||
> (left->br_startblock + left->br_blockcount != got->br_startblock) ||
> (left->br_state != got->br_state) ||
> - (left->br_blockcount + got->br_blockcount > MAXEXTLEN))
> + (left->br_blockcount + got->br_blockcount > XFS_MAX_BMBT_EXTLEN))
> return false;
>
> return true;
> diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
> index b7521c1d1db2..fa11e4c1cc41 100644
> --- a/fs/xfs/libxfs/xfs_format.h
> +++ b/fs/xfs/libxfs/xfs_format.h
> @@ -886,7 +886,7 @@ enum xfs_dinode_fmt {
> { XFS_DINODE_FMT_UUID, "uuid" }
>
> /*
> - * Max values for extlen, extnum, aextnum.
> + * Max values for ondisk inode's extent counters.
> *
> * The newly introduced data fork extent counter is a 64-bit field. However, the
> * maximum number of extents in a file is limited to 2^54 extents (assuming one
> @@ -898,7 +898,6 @@ enum xfs_dinode_fmt {
> * Rounding up 47 to the nearest multiple of bits-per-byte results in 48. Hence
> * 2^48 was chosen as the maximum data fork extent count.
> */
> -#define MAXEXTLEN ((xfs_extlen_t)((1ULL << 21) - 1)) /* 21 bits */
> #define XFS_MAX_EXTCNT_DATA_FORK ((xfs_extnum_t)((1ULL << 48) - 1)) /* Unsigned 48-bits */
> #define XFS_MAX_EXTCNT_ATTR_FORK ((xfs_extnum_t)((1ULL << 32) - 1)) /* Unsigned 32-bits */
> #define XFS_MAX_EXTCNT_DATA_FORK_OLD ((xfs_extnum_t)((1ULL << 31) - 1)) /* Signed 32-bits */
> @@ -1635,6 +1634,8 @@ typedef struct xfs_bmdr_block {
> #define BMBT_STARTOFF_MASK ((1ULL << BMBT_STARTOFF_BITLEN) - 1)
> #define BMBT_BLOCKCOUNT_MASK ((1ULL << BMBT_BLOCKCOUNT_BITLEN) - 1)
>
> +#define XFS_MAX_BMBT_EXTLEN ((xfs_extlen_t)(BMBT_BLOCKCOUNT_MASK))
> +
> /*
> * bmbt records have a file offset (block) field that is 54 bits wide, so this
> * is the largest xfs_fileoff_t that we ever expect to see.
> diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
> index 767189c7c887..409be63fd80d 100644
> --- a/fs/xfs/libxfs/xfs_inode_buf.c
> +++ b/fs/xfs/libxfs/xfs_inode_buf.c
> @@ -691,7 +691,7 @@ xfs_inode_validate_extsize(
> if (extsize_bytes % blocksize_bytes)
> return __this_address;
>
> - if (extsize > MAXEXTLEN)
> + if (extsize > XFS_MAX_BMBT_EXTLEN)
> return __this_address;
>
> if (!rt_flag && extsize > mp->m_sb.sb_agblocks / 2)
> @@ -748,7 +748,7 @@ xfs_inode_validate_cowextsize(
> if (cowextsize_bytes % mp->m_sb.sb_blocksize)
> return __this_address;
>
> - if (cowextsize > MAXEXTLEN)
> + if (cowextsize > XFS_MAX_BMBT_EXTLEN)
> return __this_address;
>
> if (cowextsize > mp->m_sb.sb_agblocks / 2)
> diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
> index 6f83d9b306ee..19313021fb99 100644
> --- a/fs/xfs/libxfs/xfs_trans_resv.c
> +++ b/fs/xfs/libxfs/xfs_trans_resv.c
> @@ -199,8 +199,8 @@ xfs_calc_inode_chunk_res(
> /*
> * Per-extent log reservation for the btree changes involved in freeing or
> * allocating a realtime extent. We have to be able to log as many rtbitmap
> - * blocks as needed to mark inuse MAXEXTLEN blocks' worth of realtime extents,
> - * as well as the realtime summary block.
> + * blocks as needed to mark inuse XFS_BMBT_MAX_EXTLEN blocks' worth of realtime
> + * extents, as well as the realtime summary block.
> */
> static unsigned int
> xfs_rtalloc_log_count(
> @@ -210,7 +210,7 @@ xfs_rtalloc_log_count(
> unsigned int blksz = XFS_FSB_TO_B(mp, 1);
> unsigned int rtbmp_bytes;
>
> - rtbmp_bytes = (MAXEXTLEN / mp->m_sb.sb_rextsize) / NBBY;
> + rtbmp_bytes = (XFS_MAX_BMBT_EXTLEN / mp->m_sb.sb_rextsize) / NBBY;
> return (howmany(rtbmp_bytes, blksz) + 1) * num_ops;
> }
>
> @@ -247,7 +247,7 @@ xfs_rtalloc_log_count(
> * the inode's bmap btree: max depth * block size
> * the agfs of the ags from which the extents are allocated: 2 * sector
> * the superblock free block counter: sector size
> - * the realtime bitmap: ((MAXEXTLEN / rtextsize) / NBBY) bytes
> + * the realtime bitmap: ((XFS_BMBT_MAX_EXTLEN / rtextsize) / NBBY) bytes
> * the realtime summary: 1 block
> * the allocation btrees: 2 trees * (2 * max depth - 1) * block size
> * And the bmap_finish transaction can free bmap blocks in a join (t3):
> @@ -299,7 +299,8 @@ xfs_calc_write_reservation(
> * the agf for each of the ags: 2 * sector size
> * the agfl for each of the ags: 2 * sector size
> * the super block to reflect the freed blocks: sector size
> - * the realtime bitmap: 2 exts * ((MAXEXTLEN / rtextsize) / NBBY) bytes
> + * the realtime bitmap: 2 exts * ((XFS_BMBT_MAX_EXTLEN / rtextsize) / NBBY)
> + * bytes
> * the realtime summary: 2 exts * 1 block
> * worst case split in allocation btrees per extent assuming 2 extents:
> * 2 exts * 2 trees * (2 * max depth - 1) * block size
> diff --git a/fs/xfs/scrub/bmap.c b/fs/xfs/scrub/bmap.c
> index a4cbbc346f60..c357593e0a02 100644
> --- a/fs/xfs/scrub/bmap.c
> +++ b/fs/xfs/scrub/bmap.c
> @@ -350,7 +350,7 @@ xchk_bmap_iextent(
> irec->br_startoff);
>
> /* Make sure the extent points to a valid place. */
> - if (irec->br_blockcount > MAXEXTLEN)
> + if (irec->br_blockcount > XFS_MAX_BMBT_EXTLEN)
> xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
> if (info->is_rt &&
> diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
> index 73a36b7be3bd..36cde254dedd 100644
> --- a/fs/xfs/xfs_bmap_util.c
> +++ b/fs/xfs/xfs_bmap_util.c
> @@ -119,14 +119,14 @@ xfs_bmap_rtalloc(
> */
> ralen = ap->length / mp->m_sb.sb_rextsize;
> /*
> - * If the old value was close enough to MAXEXTLEN that
> + * If the old value was close enough to XFS_BMBT_MAX_EXTLEN that
> * we rounded up to it, cut it back so it's valid again.
> * Note that if it's a really large request (bigger than
> - * MAXEXTLEN), we don't hear about that number, and can't
> + * XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't
> * adjust the starting point to match it.
> */
> - if (ralen * mp->m_sb.sb_rextsize >= MAXEXTLEN)
> - ralen = MAXEXTLEN / mp->m_sb.sb_rextsize;
> + if (ralen * mp->m_sb.sb_rextsize >= XFS_MAX_BMBT_EXTLEN)
> + ralen = XFS_MAX_BMBT_EXTLEN / mp->m_sb.sb_rextsize;
>
> /*
> * Lock out modifications to both the RT bitmap and summary inodes
> @@ -840,9 +840,11 @@ xfs_alloc_file_space(
> * count, hence we need to limit the number of blocks we are
> * trying to reserve to avoid an overflow. We can't allocate
> * more than @nimaps extents, and an extent is limited on disk
> - * to MAXEXTLEN (21 bits), so use that to enforce the limit.
> + * to XFS_BMBT_MAX_EXTLEN (21 bits), so use that to enforce the
> + * limit.
> */
> - resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
> + resblks = min_t(xfs_fileoff_t, (e - s),
> + (XFS_MAX_BMBT_EXTLEN * nimaps));
> if (unlikely(rt)) {
> dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
> rblocks = resblks;
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index 093758440ad5..6835adc8d62f 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -395,7 +395,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)
> @@ -407,23 +407,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);
> @@ -471,14 +471,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;
> --
> 2.30.2
>