On Tue, May 19, 2020 at 05:54:37AM -0700, Christoph Hellwig wrote:
> The actual logic looks good, but I think the new helper and another
> third set of comment explaining what is going on makes this area even
> more confusing. What about something like this instead?
This seems reasonable, but the callsite cleanups ought to be a separate
patch from the behavior change.
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index bb590a267a7f9..26f9874361cd3 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -352,22 +352,10 @@ xfs_quota_calc_throttle(
> }
>
> /*
> - * If we are doing a write at the end of the file and there are no allocations
> - * past this one, then extend the allocation out to the file system's write
> - * iosize.
> - *
> * If we don't have a user specified preallocation size, dynamically increase
> * the preallocation size as the size of the file grows. Cap the maximum size
> * at a single extent or less if the filesystem is near full. The closer the
> - * filesystem is to full, the smaller the maximum prealocation.
> - *
> - * As an exception we don't do any preallocation at all if the file is smaller
> - * than the minimum preallocation and we are using the default dynamic
> - * preallocation scheme, as it is likely this is the only write to the file that
> - * is going to be done.
> - *
> - * We clean up any extra space left over when the file is closed in
> - * xfs_inactive().
> + * filesystem is to full, the smaller the maximum preallocation.
> */
> STATIC xfs_fsblock_t
> xfs_iomap_prealloc_size(
> @@ -380,52 +368,58 @@ xfs_iomap_prealloc_size(
> struct xfs_mount *mp = ip->i_mount;
> struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
> xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
> - struct xfs_bmbt_irec prev;
> + struct xfs_iext_cursor ncur = *icur;
> + struct xfs_bmbt_irec prev, got;
> int shift = 0;
> int64_t freesp;
> xfs_fsblock_t qblocks;
> int qshift = 0;
> - xfs_fsblock_t alloc_blocks = 0;
> + xfs_fsblock_t alloc_blocks;
> + xfs_extlen_t plen;
>
> - if (offset + count <= XFS_ISIZE(ip))
> - return 0;
> -
> - if (!(mp->m_flags & XFS_MOUNT_ALLOCSIZE) &&
> - (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_allocsize_blocks)))
> + /*
> + * As an exception we don't do any preallocation at all if the file is
> + * smaller than the minimum preallocation and we are using the default
> + * dynamic preallocation scheme, as it is likely this is the only write
> + * to the file that is going to be done.
> + */
> + if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_allocsize_blocks))
> return 0;
>
> /*
> - * If an explicit allocsize is set, the file is small, or we
> - * are writing behind a hole, then use the minimum prealloc:
> + * Otherwise use the minimum prealloca size for small files, or if we
"preallocation"?
> + * are writing right after a hole.
> */
> - if ((mp->m_flags & XFS_MOUNT_ALLOCSIZE) ||
> - XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign) ||
> - !xfs_iext_peek_prev_extent(ifp, icur, &prev) ||
> + if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign) ||
> + !xfs_iext_prev_extent(ifp, &ncur, &prev) ||
> prev.br_startoff + prev.br_blockcount < offset_fsb)
> return mp->m_allocsize_blocks;
>
> /*
> - * Determine the initial size of the preallocation. We are beyond the
> - * current EOF here, but we need to take into account whether this is
> - * a sparse write or an extending write when determining the
> - * preallocation size. Hence we need to look up the extent that ends
> - * at the current write offset and use the result to determine the
> - * preallocation size.
> - *
> - * If the extent is a hole, then preallocation is essentially disabled.
> - * Otherwise we take the size of the preceding data extent as the basis
> - * for the preallocation size. If the size of the extent 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.
> + * Take the size of the contiguous preceding data extents as the basis
> + * for the preallocation size. Note that we don't care if the previous
> + * extents are written or not.
> */
> - if (prev.br_blockcount <= (MAXEXTLEN >> 1))
> - alloc_blocks = prev.br_blockcount << 1;
> - else
> + plen = prev.br_blockcount;
> + while (xfs_iext_prev_extent(ifp, &ncur, &got)) {
> + if (plen > MAXEXTLEN / 2 ||
> + got.br_startoff + got.br_blockcount != prev.br_startoff ||
> + got.br_startblock + got.br_blockcount != prev.br_startblock)
> + break;
> + plen += got.br_blockcount;
> + prev = got;
> + }
> +
> + /*
> + * 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.
> + */
> + alloc_blocks = plen * 2;
> + if (alloc_blocks > MAXEXTLEN)
> alloc_blocks = XFS_B_TO_FSB(mp, offset);
> - if (!alloc_blocks)
> - goto check_writeio;
> qblocks = alloc_blocks;
>
> /*
> @@ -494,7 +488,6 @@ xfs_iomap_prealloc_size(
> */
> while (alloc_blocks && alloc_blocks >= freesp)
> alloc_blocks >>= 4;
> -check_writeio:
> if (alloc_blocks < mp->m_allocsize_blocks)
> alloc_blocks = mp->m_allocsize_blocks;
> trace_xfs_iomap_prealloc_size(ip, alloc_blocks, shift,
> @@ -961,9 +954,16 @@ xfs_buffered_write_iomap_begin(
> if (error)
> goto out_unlock;
>
> - if (eof) {
> - prealloc_blocks = xfs_iomap_prealloc_size(ip, allocfork, offset,
> - count, &icur);
> + if (eof && offset + count > XFS_ISIZE(ip)) {
> + /*
> + * Determine the initial size of the preallocation.
> + * We clean up any extra preallocation when the file is closed.
> + */
> + if (mp->m_flags & XFS_MOUNT_ALLOCSIZE)
> + prealloc_blocks = mp->m_allocsize_blocks;
> + else
> + prealloc_blocks = xfs_iomap_prealloc_size(ip, allocfork,
> + offset, count, &icur);
I'm not sure how much we're really gaining from moving the
MOUNT_ALLOCSIZE check out to the caller, but I don't feel all that
passionate about this.
--D
> if (prealloc_blocks) {
> xfs_extlen_t align;
> xfs_off_t end_offset;
