From: Brian Foster <bfoster@redhat.com>
To: "Darrick J. Wong" <darrick.wong@oracle.com>
Cc: Christoph Hellwig <hch@infradead.org>,
Christoph Hellwig <hch@lst.de>,
linux-xfs@vger.kernel.org
Subject: Re: [PATCH v2 3/4] xfs: refactor xfs_iomap_prealloc_size
Date: Tue, 26 May 2020 09:46:53 -0400 [thread overview]
Message-ID: <20200526134653.GB5462@bfoster> (raw)
In-Reply-To: <20200524171709.GI8230@magnolia>
On Sun, May 24, 2020 at 10:17:09AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Refactor xfs_iomap_prealloc_size to be the function that dynamically
> computes the per-file preallocation size by moving the allocsize= case
> to the caller. Break up the huge comment preceding the function to
> annotate the relevant parts of the code, and remove the impossible
> check_writeio case.
>
> Suggested-by: Christoph Hellwig <hch@infradead.org>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> v2: minor rebase due to changes in previous patch
> ---
Reviewed-by: Brian Foster <bfoster@redhat.com>
> fs/xfs/xfs_iomap.c | 83 ++++++++++++++++++++++------------------------------
> 1 file changed, 35 insertions(+), 48 deletions(-)
>
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index e74a8c2c94ce..b9a8c3798e08 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 being full, the smaller the maximum preallocation.
> */
> STATIC xfs_fsblock_t
> xfs_iomap_prealloc_size(
> @@ -389,41 +377,28 @@ xfs_iomap_prealloc_size(
> int shift = 0;
> int qshift = 0;
>
> - 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:
> + * Use the minimum preallocation size for small files or if we are
> + * writing right after a hole.
> */
> - if ((mp->m_flags & XFS_MOUNT_ALLOCSIZE) ||
> - XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign) ||
> + 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 extents as the basis
> - * for the preallocation size. Note that we don't care if the previous
> - * extents are written or not.
> - *
> - * 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.
> + * Take the size of the preceding data extents as the basis for the
> + * preallocation size. Note that we don't care if the previous extents
> + * are written or not.
> */
> plen = prev.br_blockcount;
> while (xfs_iext_prev_extent(ifp, &ncur, &got)) {
> @@ -435,19 +410,25 @@ xfs_iomap_prealloc_size(
> 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;
>
> /*
> * 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.
> + * 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.
> */
> alloc_blocks = XFS_FILEOFF_MIN(roundup_pow_of_two(MAXEXTLEN),
> alloc_blocks);
> @@ -508,7 +489,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,
> @@ -975,9 +955,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);
> if (prealloc_blocks) {
> xfs_extlen_t align;
> xfs_off_t end_offset;
>
next prev parent reply other threads:[~2020-05-26 13:47 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-05-23 16:49 [PATCH v4 0/4] xfs: fix stale disk exposure after crash Darrick J. Wong
2020-05-23 16:49 ` [PATCH 1/4] xfs: don't fail unwritten extent conversion on writeback due to edquot Darrick J. Wong
2020-05-23 16:49 ` [PATCH 2/4] xfs: measure all contiguous previous extents for prealloc size Darrick J. Wong
2020-05-24 9:14 ` Christoph Hellwig
2020-05-24 17:16 ` Darrick J. Wong
2020-05-24 17:16 ` [PATCH v2 " Darrick J. Wong
2020-05-25 13:28 ` Christoph Hellwig
2020-05-26 13:46 ` Brian Foster
2020-05-23 16:49 ` [PATCH 3/4] xfs: refactor xfs_iomap_prealloc_size Darrick J. Wong
2020-05-24 17:17 ` [PATCH v2 " Darrick J. Wong
2020-05-26 13:46 ` Brian Foster [this message]
2020-05-23 16:49 ` [PATCH 4/4] xfs: force writes to delalloc regions to unwritten Darrick J. Wong
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20200526134653.GB5462@bfoster \
--to=bfoster@redhat.com \
--cc=darrick.wong@oracle.com \
--cc=hch@infradead.org \
--cc=hch@lst.de \
--cc=linux-xfs@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).