mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: liubaolin <liubaolin12138@163.com>
To: Wahid Khan <wahidzk0091@gmail.com>, linkinjeon@kernel.org
Cc: hyc.lee@gmail.com, ntfs@lists.linux.dev,
	linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org,
	stable@vger.kernel.org
Subject: Re: [PATCH v9] ntfs: convert a named $DATA stream safely when making room in a record
Date: Sat, 14 Nov 2026 18:29:27 +0800	[thread overview]
Message-ID: <63d1fb27-5d05-494f-8452-f0a7b7438f4d@163.com> (raw)
In-Reply-To: <20261114073451.367708-1-wahidzk0091@gmail.com>



在 2026/11/14 15:34, Wahid Khan 写道:
> When an attribute has to grow and the mft record is full,
> ntfs_resident_attr_resize() walks the other resident attributes and
> converts them to non-resident ones. For $DATA it always opens the
> unnamed data inode of the base inode, even if the attribute found is a
> named stream:
> 
>    tvi = ntfs_iget(sb, base_ni->mft_no);
>    ntfs_attr_make_non_resident(NTFS_I(tvi), value_len);
> 
> value_len is the length of the stream, so it does not match the
> attribute that ntfs_attr_make_non_resident() looks up for the unnamed
> inode, and the WARN_ON() on entry fires:
> 
>    WARNING: fs/ntfs/attrib.c:2115 at ntfs_attr_make_non_resident
>     ntfs_resident_attr_resize
>     ntfs_attr_expand_locked
>     ntfs_expand_for_write
>     ntfs_file_write_iter
>     vfs_write
> 
> It does not need a damaged volume. A file with an alternate data stream
> whose record has no room left is enough.
> 
> Open a named stream by name with ntfs_attr_iget(), as is done for the
> other attribute types in this loop, and keep ntfs_iget() for the
> unnamed one. The loop runs with the mft record lock held and takes no
> lock of the stream inode, so converting a stream from here needs more
> care than the plain lookup gives:
> 
> - A reader of the stream holds the folio lock and then takes the mft
>    record lock in ntfs_read_iomap_begin_resident(), the conversion takes
>    them the other way round and waits for folio 0. Take the folio with
>    FGP_NOWAIT in this loop and skip the attribute if it is busy. The loop
>    only tries to free space. The same inversion exists for the conversion
>    of the attribute being resized, which waited for folio 0 with the lock
>    held and hangs against an mmap fault or splice reader. Use FGP_NOWAIT
>    there too. The resize then fails with -EBUSY while such a reader is
>    stuck on the lock, instead of hanging.
>    Do not look for room in other attributes either: the reader keeps the
>    folio until the lock is dropped, so the attribute can neither be
>    converted nor written without waiting for it, and the loop would only
>    convert other attributes for nothing.
>    FGP_NOWAIT also fails when the folio can not be allocated, so on
>    failure look the folio up: only one that is there means a busy folio,
>    otherwise return -ENOMEM.
> 
> - A stream that is in the inode cache can be open, being written, being
>    removed or already unlinked. A write that passed its residency check
>    before the conversion carries on with a non-resident attribute, and
>    a stream in the middle of ntfs_stream_finish_remove() is converted
>    under its feet. Convert only a stream that is not cached.
> 
> - An attribute inode of a file that has no links left is evicted on the
>    last iput() with its dirty folio, so what was converted is lost and
>    an open file reads its extended attributes back as missing. Convert
>    nothing, of any type, in a file that is being deleted or has no links
>    left.
> 
> - The unnamed data is converted through the file's own inode, whose
>    i_rwsem only a resize of the unnamed data itself holds. When a stream
>    or an extended attribute is being resized, a writer of the file can
>    have passed its residency check and carry on with a non-resident
>    attribute (iomap_iter warnings, recursive mrec_lock). When the
>    unnamed data is the attribute being resized, its conversion was just
>    tried by the caller. Do not convert the unnamed data from this loop.
> 
> - Do not convert the attribute that is being resized either. Its
>    conversion was just tried and failed, for instance on a busy folio,
>    and a second try that succeeds leaves the resize to go on with the
>    resident layout of a record that is now non-resident.
> 
> - The lookup of a stream ignores case, so a stream whose name differs
>    only in case from an earlier one resolves to that one and the length
>    does not match again. Compare the names exactly.
> 
> Fixes: 495e90fa3348 ("ntfs: update attrib operations")
> Cc: stable@vger.kernel.org # v7.1+
> Signed-off-by: Wahid Khan <wahidzk0091@gmail.com>
> ---
> v9: A busy folio on the resized attribute returns -EBUSY and not -ENOSPC,
>      as Namjae asked (-EAGAIN would reach user space and index.c uses it for
>      its own retry, -ENOSPC is not true as the record is not full).
> v8: Sashiko's review of v7: the fall-through on a busy folio could still
>      convert other attributes for nothing, also below the record size (the
>      attribute may not fit resident either), and a resident write that
>      follows waits for folio 0 under mrec_lock. A busy folio on the
>      resized attribute now fails the resize with -ENOSPC at any size,
>      nothing is converted. A forced -EAGAIN while growing an EA to 800
>      bytes now fails and the EA keeps its old value, also after a remount.
>      Also: FGP_NOWAIT fails with -EAGAIN when it can not allocate the folio
>      too, which would have shown up as a bogus -ENOSPC under memory
>      pressure. Now only a folio that is in the cache means busy, otherwise
>      -ENOMEM.
> v7: Sashiko's review of v6: when the resized attribute cannot be resident
>      at the new size (newsize >= mft record size), a busy folio (-EAGAIN,
>      mapped to -ENOSPC) still ran the make-room loop and converted the other
>      streams before the resize failed with -ENOSPC anyway. Reproduced with a
>      forced -EAGAIN (setxattr of 1500 bytes fails, two streams converted),
>      fixed: the resize fails right away and nothing is converted.
> v6: Sashiko's review of v5: when the conversion of the resized attribute
>      returns -EAGAIN (busy folio) and is mapped to -ENOSPC, the loop could
>      reach that attribute itself, convert it and resize its record as if it
>      were resident. Reproduced with one forced -EAGAIN (the EA is lost, the
>      resize fails with -EINVAL), fixed: the attribute being resized is never
>      converted from the loop, and neither is the unnamed data (its branch
>      was dead code once that is skipped).
> v5: Sashiko's review of v4 found more, each reproduced with a forced make-room
>      pass and a debug delay, fails before and passes after:
>      - the WofCompressedData stream of a WOF file was converted, and the
>        file read stale clusters until writeback (249 of 250 bytes wrong)
>      - an attribute converted in a file with no links left was evicted
>        with its dirty folio (open file reads its EA back as missing)
>      - a resize of a stream converted the unnamed data under a writer of
>        the file (iomap_iter WARNs, recursive mrec_lock)
>      - the conversion of the resized attribute itself waited for folio 0
>        with mrec_lock held (hung task against mmap fault and splice)
>      The six v4 scenarios still pass.
> v4: v3 (convert a named stream via ntfs_attr_iget()) can deadlock against
>      a reader of the stream and has other races with an open or removed
>      stream. Each is reproduced with a forced make-room pass and a debug
>      delay, fails on v3 and passes here: reader/converter deadlock
>      (hung task), write continuing on a converted attribute (iomap_iter
>      WARNINGs, recursive locking), unlinked file with an open stream (mft
>      record reported corrupt), stream converted during its own removal,
>      and a stream pair that differs only in case (WARN in
>      ntfs_attr_make_non_resident).
> v3: use ntfs_attr_iget() for a named stream instead of skipping it (v2).
>   fs/ntfs/attrib.c | 109 +++++++++++++++++++++++++++++++++++++++++++----
>   fs/ntfs/inode.c  |  19 +++++++++
>   fs/ntfs/inode.h  |   2 +
>   3 files changed, 121 insertions(+), 9 deletions(-)
> 
> diff --git a/fs/ntfs/attrib.c b/fs/ntfs/attrib.c
> index ce7c1b524180..613b6482d720 100644
> --- a/fs/ntfs/attrib.c
> +++ b/fs/ntfs/attrib.c
> @@ -1975,7 +1975,21 @@ int ntfs_resident_attr_value_resize(struct mft_record *m, struct attr_record *a,
>    * inode i_size is that this is not necessarily uptodate.  This happens when
>    * ntfs_attr_make_non_resident() is called in the ->truncate call path(s).
>    */
> +static int __ntfs_attr_make_non_resident(struct ntfs_inode *ni, const u32 data_size,
> +		bool nowait);
> +
>   int ntfs_attr_make_non_resident(struct ntfs_inode *ni, const u32 data_size)
> +{
> +	return __ntfs_attr_make_non_resident(ni, data_size, false);
> +}
> +
> +/*
> + * With @nowait the folio lock is only tried: a caller that holds mrec_lock
> + * must not wait for a folio lock, the read path takes them the other way
> + * round. Fails with -EAGAIN if the folio is locked.
> + */
> +static int __ntfs_attr_make_non_resident(struct ntfs_inode *ni, const u32 data_size,
> +		bool nowait)
>   {
>   	s64 new_size;
>   	struct inode *vi = VFS_I(ni);
> @@ -2056,10 +2070,23 @@ int ntfs_attr_make_non_resident(struct ntfs_inode *ni, const u32 data_size)
>   		 * outside all ntfs locks, we need to get the folio now.
>   		 */
>   		folio = __filemap_get_folio(vi->i_mapping, 0,
> -					    FGP_CREAT | FGP_LOCK,
> +					    FGP_CREAT | FGP_LOCK |
> +					    (nowait ? FGP_NOWAIT : 0),
>   					    mapping_gfp_mask(vi->i_mapping));
>   		if (IS_ERR(folio)) {
>   			err = -ENOMEM;
> +			if (nowait) {
> +				/*
> +				 * FGP_NOWAIT also fails when it can not
> +				 * allocate the folio. Only a folio that is
> +				 * there and locked means a busy folio.
> +				 */
> +				folio = filemap_get_folio(vi->i_mapping, 0);
> +				if (!IS_ERR(folio)) {
> +					folio_put(folio);
> +					err = -EAGAIN;
> +				}
> +			}
>   			goto err_out;
>   		}
>   
> @@ -4895,8 +4922,23 @@ static int ntfs_resident_attr_resize(struct ntfs_inode *attr_ni, const s64 newsi
>   	/* There is not enough space in the mft record to perform the resize. */
>   
>   	/* Make the attribute non-resident if possible. */
> -	err = ntfs_attr_make_non_resident(attr_ni,
> -			le32_to_cpu(ctx->attr->data.resident.value_length));
> +	err = __ntfs_attr_make_non_resident(attr_ni,
> +			le32_to_cpu(ctx->attr->data.resident.value_length), true);
> +	/*
> +	 * A reader holding folio 0 waits for mrec_lock, which we hold. Do not
> +	 * wait for it and do not look for room elsewhere either: the reader
> +	 * keeps the folio until we drop the lock, so the attribute can neither
> +	 * be converted nor written without waiting for it, and the loop below
> +	 * would only convert other attributes for nothing.
> +	 */
> +	if (err == -EAGAIN) {
> +		/*
> +		 * Not -EAGAIN, it would reach user space and index.c uses it
> +		 * for its own retry. Not -ENOSPC, the record is not full.
> +		 */
> +		err = -EBUSY;
> +		goto put_err_out;
> +	}
>   	if (!err) {
>   		mark_mft_record_dirty(ctx->ntfs_ino);
>   		ntfs_attr_put_search_ctx(ctx);
> @@ -4913,12 +4955,14 @@ static int ntfs_resident_attr_resize(struct ntfs_inode *attr_ni, const s64 newsi
>   	while (!(err = ntfs_attr_lookup(AT_UNUSED, NULL, 0, 0, 0, NULL, 0, ctx))) {
>   		struct inode *tvi;
>   		struct attr_record *a;
> +		__le16 *name;
>   		u32 value_len;
>   
>   		a = ctx->attr;
>   		if (a->non_resident || a->type == AT_ATTRIBUTE_LIST)
>   			continue;
>   		value_len = le32_to_cpu(a->data.resident.value_length);
> +		name = (__le16 *)((u8 *)a + le16_to_cpu(a->name_offset));
>   
>   		if (ntfs_attr_can_be_non_resident(vol, a->type))
>   			continue;
> @@ -4933,18 +4977,65 @@ static int ntfs_resident_attr_resize(struct ntfs_inode *attr_ni, const s64 newsi
>   		if (a->type == AT_DATA && !value_len)
>   			continue;
>   
> -		if (a->type == AT_DATA)
> -			tvi = ntfs_iget(sb, base_ni->mft_no);
> -		else
> -			tvi = ntfs_attr_iget(VFS_I(base_ni), a->type,
> -				(__le16 *)((u8 *)a + le16_to_cpu(a->name_offset)),
> +		/*
> +		 * The attribute inode of an unlinked file is evicted on the
> +		 * last iput() together with its dirty folio.
> +		 */
> +		if (NInoBeingDeleted(base_ni) || !VFS_I(base_ni)->i_nlink)
> +			continue;
> +
> +		/*
> +		 * Not the attribute being resized. Its conversion was tried
> +		 * above and failed, for instance on a busy folio, and
> +		 * converting it here would leave the resize to go on with the
> +		 * resident layout of a non-resident record.
> +		 */
> +		if (a->type == attr_ni->type &&
> +		    a->name_length == attr_ni->name_len &&
> +		    (!a->name_length ||
> +		     !memcmp(name, attr_ni->name,
> +			     a->name_length * sizeof(__le16))))
> +			continue;
> +
> +		/*
> +		 * Not the unnamed data either. Only the resize of the unnamed
> +		 * data itself holds its i_rwsem, a writer of the file can be
> +		 * between its residency check and the mft record lock.
> +		 */
> +		if (a->type == AT_DATA && !a->name_length)
> +			continue;
> +
> +		/*
> +		 * A named $DATA stream is converted only if nobody has it open:
> +		 * an open one can be unlinked, being removed or in use. A WOF
> +		 * file reads its stream from the device, so the stream must
> +		 * stay resident.
> +		 */
> +		if (a->type == AT_DATA) {
> +			if (NInoWofCompressed(base_ni))
> +				continue;
> +			tvi = ntfs_attr_ilookup(VFS_I(base_ni), a->type,
> +					name, a->name_length);
> +			if (tvi) {
> +				iput(tvi);
> +				continue;
> +			}
> +		}
> +		tvi = ntfs_attr_iget(VFS_I(base_ni), a->type, name,
>   				a->name_length);
> +		/* the lookup ignores case for streams, ours does not */
> +		if (!IS_ERR(tvi) && a->type == AT_DATA &&
> +		    memcmp(NTFS_I(tvi)->name, name,
> +			   a->name_length * sizeof(__le16))) {
> +			iput(tvi);
> +			continue;
> +		}
>   		if (IS_ERR(tvi)) {
>   			ntfs_error(sb, "Couldn't open attribute");
>   			continue;
>   		}
>   
> -		if (ntfs_attr_make_non_resident(NTFS_I(tvi), value_len)) {
> +		if (__ntfs_attr_make_non_resident(NTFS_I(tvi), value_len, true)) {
>   			iput(tvi);
>   			continue;
>   		}
> diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
> index 62dd5bd5bb81..ec9c7b219192 100644
> --- a/fs/ntfs/inode.c
> +++ b/fs/ntfs/inode.c
> @@ -287,6 +287,25 @@ struct inode *ntfs_attr_iget(struct inode *base_vi, __le32 type,
>   	return vi;
>   }
>   
> +/*
> + * ntfs_attr_ilookup - find an attribute inode that is already in the cache
> + *
> + * Like ntfs_attr_iget() but never reads anything. Returns the inode with an
> + * increased reference count, or NULL if it is not cached.
> + */
> +struct inode *ntfs_attr_ilookup(struct inode *base_vi, __le32 type,
> +		__le16 *name, u32 name_len)
> +{
> +	struct ntfs_attr na = {
> +		.mft_no = base_vi->i_ino,
> +		.type = type,
> +		.name = name,
> +		.name_len = name_len,
> +	};
> +
> +	return ilookup5(base_vi->i_sb, na.mft_no, ntfs_test_inode, &na);
> +}
> +
>   /*
>    * ntfs_index_iget - obtain a struct inode corresponding to an index
>    * @base_vi:	vfs base inode containing the index related attributes
> diff --git a/fs/ntfs/inode.h b/fs/ntfs/inode.h
> index a18cbcf1c631..7ea52c59c04b 100644
> --- a/fs/ntfs/inode.h
> +++ b/fs/ntfs/inode.h
> @@ -326,6 +326,8 @@ struct ntfs_attr {
>   int ntfs_test_inode(struct inode *vi, void *data);
>   int ntfs_test_inode_rcu(struct inode *vi, void *data);
>   struct inode *ntfs_iget(struct super_block *sb, u64 mft_no);
> +struct inode *ntfs_attr_ilookup(struct inode *base_vi, __le32 type,
> +		__le16 *name, u32 name_len);
>   struct inode *ntfs_attr_iget(struct inode *base_vi, __le32 type,
>   		__le16 *name, u32 name_len);
>   struct inode *ntfs_index_iget(struct inode *base_vi, __le16 *name,


Looks good to me.

Reviewed-by: Baolin Liu <liubaolin@kylinos.cn>


  reply	other threads:[~2026-11-14 10:29 UTC|newest]

Thread overview: 24+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-06 12:45 [PATCH v2 0/3] ntfs: three fixes for crafted images, found by fuzzing Wahid Khan
2026-11-06 12:45 ` [PATCH v2 1/3] ntfs: do not read an index block outside $INDEX_ALLOCATION Wahid Khan
2026-11-06 12:45 ` [PATCH v2 2/3] ntfs: open the index allocation before reading or writing an index block Wahid Khan
2026-11-06 12:45 ` [PATCH v2 3/3] ntfs: do not convert a named $DATA stream when making room in a record Wahid Khan
2026-11-06 13:31   ` Wahid Khan
2026-11-06 14:12     ` Namjae Jeon
2026-11-07 19:28       ` [PATCH v3] ntfs: open a named $DATA stream by name " Wahid Khan
2026-11-08  2:14         ` Namjae Jeon
2026-11-07 19:28       ` [PATCH v2 3/3] ntfs: do not convert a named $DATA stream " Wahid Khan
2026-11-08  8:03       ` [PATCH v4] ntfs: convert a named $DATA stream safely " Wahid Khan
2026-11-08 12:50         ` Namjae Jeon
2026-11-08 22:11           ` Wahid Khan
2026-11-08 22:12           ` [PATCH v5] " Wahid Khan
2026-11-09  7:07             ` [PATCH v6] " Wahid Khan
2026-11-09 14:24               ` [PATCH v7] " Wahid Khan
2026-11-09 17:32                 ` [PATCH v8] " Wahid Khan
2026-11-11  2:07                   ` Namjae Jeon
2026-11-12  7:40                     ` Wahid Khan
2026-11-13  1:47                       ` Namjae Jeon
2026-11-14  7:34                   ` [PATCH v9] " Wahid Khan
2026-11-14 10:29                     ` liubaolin [this message]
2026-11-15  0:29                     ` Namjae Jeon
2026-11-08  8:08       ` [PATCH v2 3/3] ntfs: do not convert a named $DATA stream " Wahid Khan
2026-11-06 13:31 ` [PATCH v2 0/3] ntfs: three fixes for crafted images, found by fuzzing Namjae Jeon

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=63d1fb27-5d05-494f-8452-f0a7b7438f4d@163.com \
    --to=liubaolin12138@163.com \
    --cc=hyc.lee@gmail.com \
    --cc=linkinjeon@kernel.org \
    --cc=linux-fsdevel@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=ntfs@lists.linux.dev \
    --cc=stable@vger.kernel.org \
    --cc=wahidzk0091@gmail.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®