From: liubaolin <liubaolin12138@163.com>
To: Zhan Xusheng <zhanxusheng1024@gmail.com>,
linkinjeon@kernel.org, hyc.lee@gmail.com
Cc: ntfs@lists.linux.dev, linux-kernel@vger.kernel.org,
stable@vger.kernel.org, zhanxusheng@xiaomi.com
Subject: Re: [PATCH v8] ntfs: trim the sizes after a short write
Date: Fri, 20 Nov 2026 15:19:55 +0800 [thread overview]
Message-ID: <cd7bbf5c-e88d-4beb-9cdb-bb9bc8e3fd62@163.com> (raw)
In-Reply-To: <20261120023504.4134966-1-zhanxusheng1024@gmail.com>
在 2026/11/20 10:35, Zhan Xusheng 写道:
> From: Zhan Xusheng <zhanxusheng@xiaomi.com>
>
> ntfs_file_write_iter() moves the data size and, for a non-resident
> uncompressed file, the initialized size to pos + count before the copy.
> __ntfs_extend_initialized_size() only zeroes [old initialized size, pos),
> so the range [pos, pos + count) is initialized only by the copy itself.
> When iomap_file_buffered_write() copies less than count, it returns a
> positive short count and the error rollback at out: does not run. The
> file keeps the size pos + count, and [pos + ret, pos + count) reads back
> whatever the freed clusters held before, also after a remount. A local
> user can read the old contents of freed clusters this way.
>
> Run the existing rollback for a short write as well, and roll the data
> size back to the end of what was written, keeping the clusters that were
> allocated on disk before the write, such as space reserved with
> FALLOC_FL_KEEP_SIZE. Keep the initialized size, as a page fault through
> a shared mapping may rely on it while the write is stalled on its
> source, and zero what the write did not reach, up to the end of the
> block holding pos + count. Only if that fails, take the initialized
> size back to where the zeroing started, if it is above that.
>
> Fixes: b041ca562526 ("ntfs: update iomap and address space operations")
> Cc: stable@vger.kernel.org
> Signed-off-by: Zhan Xusheng <zhanxusheng@xiaomi.com>
> ---
> v8: when taking the data size back without truncating, mark the file
> name dirty as ntfs_non_resident_attr_shrink() does. If the inode was
> written while the write waited on its source, the size in the directory
> index otherwise stays at the extended value (Baolin).
> v7: when taking the data size back, keep the clusters allocated on disk
> before the write instead of truncating, which freed space reserved
> with FALLOC_FL_KEEP_SIZE; a failed write already did so before this
> patch (Hyunchul). Holes and delayed allocations past the data size,
> such as the preallocation of an earlier extending write, are freed as
> before. Baolin's Reviewed-by on v6 is not carried over, as this
> changes the data size rollback he reviewed.
> v6: cap that fallback at the current initialized size, which a failed
> extension before the write can leave below pos (Baolin).
> v5 (Baolin):
> - start the zeroing at pos, not at the old initialized size, which
> overwrote data stored through a shared mapping below pos
> - do the same for a direct write, instead of truncating the page cache
> and taking the initialized size back
> - if the zeroing fails, take the initialized size back to where it
> started, instead of skipping both rollbacks
> v4: for a buffered write, zero the unwritten range instead of
> truncating the page cache and taking the initialized size back, which
> dropped data stored through a shared mapping during the copy (Baolin).
> v3: clear the cache up to EOF, not up to the extended initialized
> size, which left the rest of the block holding pos + count (Baolin).
> v2: also clear the cached tail of the last block, which v1 left in
> place when the write stayed inside the old data size (Baolin).
>
> v7: https://lore.kernel.org/all/20261119022715.3636699-1-zhanxusheng1024@gmail.com/
> v6: https://lore.kernel.org/all/20261117082021.2947603-1-zhanxusheng1024@gmail.com/
> v5: https://lore.kernel.org/all/20261116091121.2547497-1-zhanxusheng1024@gmail.com/
> v4: https://lore.kernel.org/all/20261113050148.1466682-1-zhanxusheng1024@gmail.com/
> v3: https://lore.kernel.org/all/20261112093233.1118469-1-zhanxusheng1024@gmail.com/
> v2: https://lore.kernel.org/all/20261112030815.982026-1-zhanxusheng1024@gmail.com/
> v1: https://lore.kernel.org/all/20261111093459.660484-1-zhanxusheng1024@gmail.com/
>
> Tested in a VM on ntfs-next 4862a81576e3, with all free space filled
> with a known pattern first. Short buffered writes of 4M, old data
> readable after drop_caches and after remount, 3 runs each:
>
> unfixed v8
> fallocated, ends block-aligned 3137536 0
> fallocated, ends inside a block 3141332 0
> fallocated, unaligned start 3137536 0
> same, pos + count in that page - 0
> append 3137536 0
>
> Marker stored through a shared mapping at 64K while pwritev() is
> stalled on a userfaultfd source page, state after remount, with and
> without fallocate():
>
> unfixed v8
> buffered 4K at 128K, EFAULT lost kept
> O_DIRECT 12K at 0, EFAULT lost kept
> buffered 12K at 0, short 8192 kept kept
>
> 1M reserved with FALLOC_FL_KEEP_SIZE, then a 12K write at 0, 512-byte
> blocks after remount:
>
> unfixed v8
> short, 8192 written 2048 2048
> failed, EFAULT 0 2048
>
> A short write past 8K reserved this way frees what it allocated beyond
> the 8K and keeps the 8K. A store into [pos + ret, pos + count) itself
> during the write is zeroed, as that range belongs to the write. With
> iomap_zero_range() failing (injected -ENOMEM), a 32K write to a 16K
> file that returns 12288 leaves the size at 28K with no old data, also
> after remount.
>
> In the 8192 case above, with syncfs() while the write waits on its
> source, the data size in the directory index after remount is 12288
> with v7 and 8192 with v8.
>
> fsx (buffered, no-mmap, O_DIRECT and mixed), compressed files,
> fallocate, insert/collapse range and punch hole give the same results
> with v8 as with v7.
> ---
> fs/ntfs/attrib.c | 37 +++++++++++++++
> fs/ntfs/attrib.h | 1 +
> fs/ntfs/file.c | 121 +++++++++++++++++++++++++++++++++++++++++++----
> 3 files changed, 151 insertions(+), 8 deletions(-)
>
> diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
> index 29eae1eb3d02..ccaeb484aaa0 100644
> --- a/fs/ntfs/attrib.c
> +++ b/fs/ntfs/attrib.c
> @@ -2456,6 +2456,43 @@ int ntfs_attr_set_initialized_size(struct ntfs_inode *ni, loff_t new_size)
> return err;
> }
>
> +/*
> + * ntfs_attr_set_data_size - set the data size of a non-resident attribute
> + * without changing its allocation
> + *
> + * The caller holds mrec_lock. @new_size must not be below the initialized
> + * size or above the allocated size.
> + */
> +int ntfs_attr_set_data_size(struct ntfs_inode *ni, loff_t new_size)
> +{
> + struct ntfs_attr_search_ctx *ctx;
> + struct ntfs_inode *base_ni = ntfs_base_inode(ni);
> + int err = 0;
> +
> + if (!NInoNonResident(ni) || new_size < ni->initialized_size ||
> + new_size > ni->allocated_size)
> + return -EINVAL;
> +
> + ctx = ntfs_attr_get_search_ctx(base_ni, NULL);
> + if (!ctx)
> + return -ENOMEM;
> +
> + err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len,
> + CASE_SENSITIVE, 0, NULL, 0, ctx);
> + if (err)
> + goto out_ctx;
> +
> + ctx->attr->data.non_resident.data_size = cpu_to_le64(new_size);
> + ni->data_size = new_size;
> + /* Update data size in the index. */
> + if (ni->type == AT_DATA && ni->name == AT_UNNAMED)
> + NInoSetFileNameDirty(ni);
> + mark_mft_record_dirty(ctx->ntfs_ino);
> +out_ctx:
> + ntfs_attr_put_search_ctx(ctx);
> + return err;
> +}
> +
> /*
> * ntfs_make_room_for_attr - make room for an attribute inside an mft record
> * @m: mft record
> diff --git a/fs/ntfs/attrib.h b/fs/ntfs/attrib.h
> index bee91c9f6f81..edb62826a6ab 100644
> --- a/fs/ntfs/attrib.h
> +++ b/fs/ntfs/attrib.h
> @@ -102,6 +102,7 @@ int ntfs_attr_make_non_resident(struct ntfs_inode *ni, const u32 data_size);
> int ntfs_attr_set(struct ntfs_inode *ni, const s64 ofs, const s64 cnt,
> const u8 val);
> int ntfs_attr_set_initialized_size(struct ntfs_inode *ni, loff_t new_size);
> +int ntfs_attr_set_data_size(struct ntfs_inode *ni, loff_t new_size);
> int ntfs_attr_open(struct ntfs_inode *ni, const __le32 type,
> __le16 *name, u32 name_len);
> void ntfs_attr_close(struct ntfs_inode *n);
> diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
> index a52483d16c6e..25034735d249 100644
> --- a/fs/ntfs/file.c
> +++ b/fs/ntfs/file.c
> @@ -843,6 +843,34 @@ static int ntfs_expand_for_write(struct ntfs_inode *ni, loff_t end)
> return err;
> }
>
> +/*
> + * End of the last run of clusters allocated on disk. Holes and delayed
> + * allocations past it, such as the preallocation of an extending write,
> + * do not count. Falls back to the allocated size if the runlist is not
> + * fully mapped.
> + */
> +static loff_t ntfs_allocated_end_on_disk(struct ntfs_inode *ni)
> +{
> + loff_t end = ni->allocated_size;
> + ssize_t i;
> +
> + down_read(&ni->runlist.lock);
> + if (NInoFullyMapped(ni) && ni->runlist.rl) {
> + end = 0;
> + for (i = ni->runlist.count - 1; i >= 0; i--) {
> + struct runlist_element *rl = &ni->runlist.rl[i];
> +
> + if (rl->length && rl->lcn >= 0) {
> + end = ntfs_cluster_to_bytes(ni->vol,
> + rl->vcn + rl->length);
> + break;
> + }
> + }
> + }
> + up_read(&ni->runlist.lock);
> + return end;
> +}
> +
> ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> {
> struct file *file = iocb->ki_filp;
> @@ -853,7 +881,7 @@ ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> ssize_t count;
> loff_t pos, end;
> int err;
> - loff_t old_data_size, old_init_size;
> + loff_t old_data_size, old_init_size, old_alloc_size;
>
> if (NVolShutdown(vol))
> return -EIO;
> @@ -901,6 +929,10 @@ ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
>
> old_data_size = ni->data_size;
> old_init_size = ni->initialized_size;
> + old_alloc_size = ni->allocated_size;
> + if (NInoNonResident(ni) && !NInoCompressed(ni) &&
> + old_alloc_size > round_up(old_data_size, vol->cluster_size))
> + old_alloc_size = ntfs_allocated_end_on_disk(ni);
>
> if (end > old_data_size) {
> ret = ntfs_expand_for_write(ni, end);
> @@ -928,10 +960,21 @@ ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> ret = iomap_file_buffered_write(iocb, from, ntfs_write_iomap_next,
> &ntfs_iomap_folio_ops, NULL);
> out:
> - if (ret < 0 && ret != -EIOCBQUEUED) {
> + /*
> + * Both sizes were moved to end before the copy, so a short write,
> + * like a failed one, must take back what it did not write.
> + */
> + if (ret < count && ret != -EIOCBQUEUED) {
> + loff_t new_init_size = old_init_size;
> + loff_t new_data_size = old_data_size;
> int init_err = 0;
> int data_err = 0;
>
> + if (ret > 0) {
> + new_init_size = max(old_init_size, pos + ret);
> + new_data_size = max(old_data_size, pos + ret);
> + }
> +
> /*
> * Like ntfs_setattr_size(): __ntfs_attr_truncate_vfs()
> * expects the invalidate lock held across the size
> @@ -939,14 +982,59 @@ ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> */
> filemap_invalidate_lock(vi->i_mapping);
>
> + /*
> + * A page fault through a shared mapping may have used the
> + * extended initialized size while the write was stalled on
> + * its source, so keep that size and zero what the write did
> + * not reach instead. [old_init_size, pos) was zeroed before
> + * the write. Past end, zero the rest of the block that a
> + * buffered copy may have read from disk, unless such a fault
> + * already moved the initialized size past end and zeroed it.
> + */
> + if (NInoNonResident(ni) && !NInoCompressed(ni) &&
> + ni->initialized_size > new_init_size) {
> + loff_t zstart = max(pos, new_init_size);
> + loff_t zend = ni->initialized_size > end ? end :
> + round_up(end, i_blocksize(vi));
> + int err = 0;
> +
> + zend = min(zend, new_data_size);
> + if (zend > zstart) {
> + err = iomap_zero_range(vi, zstart,
> + zend - zstart, NULL,
> + ntfs_seek_iomap_next,
> + &ntfs_iomap_folio_ops, NULL);
> + /* A direct read must not see the old blocks. */
> + if (!err && iocb->ki_flags & IOCB_DIRECT)
> + err = filemap_write_and_wait_range(
> + vi->i_mapping, zstart, zend - 1);
> + }
> + if (!err)
> + new_init_size = min(ni->initialized_size,
> + new_data_size);
> + else
> + new_init_size = min3(ni->initialized_size,
> + zstart, new_data_size);
> + }
> +
> /* ntfs_attr_set_initialized_size() rejects a resident one. */
> - if (ni->initialized_size != old_init_size &&
> + if (ni->initialized_size != new_init_size &&
> NInoNonResident(ni)) {
> struct ntfs_inode *mrec_ni = ntfs_base_inode(ni);
>
> + /*
> + * Only reached when the zeroing above failed or did
> + * not apply. Drop what was cached past the new
> + * initialized size, as __ntfs_extend_initialized_size()
> + * does.
> + */
> + if (ni->initialized_size > new_init_size)
> + truncate_pagecache_range(vi, new_init_size,
> + max_t(loff_t, i_size_read(vi),
> + ni->initialized_size) - 1);
> mutex_lock(&mrec_ni->mrec_lock);
> init_err = ntfs_attr_set_initialized_size(ni,
> - old_init_size);
> + new_init_size);
> mutex_unlock(&mrec_ni->mrec_lock);
> }
> /*
> @@ -955,13 +1043,30 @@ ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> * the uninitialized tail, so skip it unless the rollback
> * above restored that size.
> */
> - if (ni->data_size != old_data_size && !init_err) {
> + if (ni->data_size != new_data_size && !init_err) {
> struct ntfs_inode *mrec_ni = ntfs_base_inode(ni);
>
> - truncate_setsize(vi, old_data_size);
> + truncate_setsize(vi, new_data_size);
> mutex_lock(&mrec_ni->mrec_lock);
> - data_err = __ntfs_attr_truncate_vfs(ni, old_data_size,
> - old_data_size);
> + if (NInoNonResident(ni) && !NInoCompressed(ni)) {
> + /*
> + * Only free what the write allocated, not
> + * clusters that were there before, such as
> + * space reserved with FALLOC_FL_KEEP_SIZE.
> + */
> + loff_t keep = max(new_data_size,
> + old_alloc_size);
> +
> + if (ni->allocated_size > keep)
> + data_err = __ntfs_attr_truncate_vfs(ni,
> + keep, keep);
> + if (!data_err && ni->data_size != new_data_size)
> + data_err = ntfs_attr_set_data_size(ni,
> + new_data_size);
> + } else {
> + data_err = __ntfs_attr_truncate_vfs(ni,
> + new_data_size, new_data_size);
> + }
> mutex_unlock(&mrec_ni->mrec_lock);
> /* Like ntfs_setattr_size(): stay on the durable size. */
> if (data_err)
>
> base-commit: 4862a81576e3b20ba40cb94a38c5df0450047ffe
Looks good to me.
Reviewed-by: Baolin Liu <liubaolin@kylinos.cn>
prev parent reply other threads:[~2026-11-20 7:20 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 2:35 Zhan Xusheng
2026-11-20 7:19 ` liubaolin [this message]
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=cd7bbf5c-e88d-4beb-9cdb-bb9bc8e3fd62@163.com \
--to=liubaolin12138@163.com \
--cc=hyc.lee@gmail.com \
--cc=linkinjeon@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=ntfs@lists.linux.dev \
--cc=stable@vger.kernel.org \
--cc=zhanxusheng1024@gmail.com \
--cc=zhanxusheng@xiaomi.com \
/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
all inboxes | Powered by JetHome®