From: Mark Brown <broonie@kernel.org>
To: Namjae Jeon <linkinjeon@kernel.org>
Cc: Chi Zhiling <chizhiling@kylinos.cn>,
Christian Brauner <brauner@kernel.org>,
Joanne Koong <joannelkoong@gmail.com>,
Linux Kernel Mailing List <linux-kernel@vger.kernel.org>,
Linux Next Mailing List <linux-next@vger.kernel.org>
Subject: linux-next: manual merge of the exfat tree with the origin tree
Date: Wed, 18 Nov 2026 13:29:15 +0000 [thread overview]
Message-ID: <av2oK6fn2XToTjxV@sirena.org.uk> (raw)
[-- Attachment #1: Type: text/plain, Size: 13377 bytes --]
Hi all,
Today's linux-next merge of the exfat tree got a conflict in:
fs/exfat/file.c
between commit:
9e8fc16dc6b47 ("iomap: pass iomap_iter_next_fn directly instead of struct iomap_ops")
from the origin tree and commits:
cfdee4e5f5764 ("exfat: coordinate direct writes with mmap faults")
e70ec3eaac957 ("exfat: increase VDL before unlocking initialized folios")
44c870b1a1216 ("exfat: zero invalid VDL tails in buffered and direct reads")
from the exfat tree. This one really wants some double checking.
I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging. You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.
diff --cc fs/exfat/file.c
index 435bbef288b83,c7991e98a07ab..0000000000000
--- a/fs/exfat/file.c
+++ b/fs/exfat/file.c
@@@ -804,6 -847,105 +847,105 @@@ static int exfat_extend_valid_size(stru
return ret;
}
+ /*
+ * A later mmap fault can initialize the gap up to its folio. Prepare and
+ * write back through the DIO range and its boundary folio so that gap
+ * initialization in a later folio does not dirty the DIO range.
+ * i_rwsem serializes preparation, allowing later overwrites to reuse the
+ * prepared range without dirtying folios containing in-flight DIO.
+ */
+ static int exfat_prepare_dio_range(struct inode *inode, loff_t end)
+ {
+ struct address_space *mapping = inode->i_mapping;
+ struct exfat_inode_info *ei = EXFAT_I(inode);
+ loff_t valid, start, size;
+ int ret = 0;
+
+ filemap_invalidate_lock(mapping);
+ size = i_size_read(inode);
+ valid = exfat_get_valid_size(ei);
+ start = max(valid, exfat_get_zeroed_size(ei));
+ end = max(valid, min(end, size));
+ end = min_t(u64, round_up((u64)end, mapping_max_folio_size(mapping)),
+ size);
+ if (start < end) {
+ unmap_mapping_range(mapping, start, end - start, 0);
+ ret = exfat_prepare_range(inode, start, end, false);
+ if (!ret)
+ ret = filemap_write_and_wait_range(mapping, start, end - 1);
+ if (!ret)
+ exfat_advance_zeroed_size(ei,
+ round_up(end, i_blocksize(inode)));
+ }
+ filemap_invalidate_unlock(mapping);
+ return ret;
+ }
+
+ static int exfat_file_write_dio_end_io(struct kiocb *iocb, ssize_t size,
+ int error, unsigned int flags)
+ {
+ struct inode *inode = file_inode(iocb->ki_filp);
+ struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
+ struct exfat_dio *dio = container_of(iocb, struct exfat_dio, iocb);
+ struct folio *folio = NULL;
+ loff_t end = dio->start + size;
+ bool dirtied = false;
+
+ if (error || !size)
+ return error;
+
+ if (i_size_read(inode) < end)
+ folio = exfat_prepare_isize_extended(inode, i_size_read(inode),
+ end);
+
+ mutex_lock(&sbi->s_lock);
+ if (i_size_read(inode) < end) {
+ i_size_write(inode, end);
+ dirtied = true;
+ }
+
+ if (dio->start <= exfat_get_valid_size(EXFAT_I(inode)) &&
+ exfat_advance_valid_size(EXFAT_I(inode), end))
+ dirtied = true;
+ if (dirtied)
+ mark_inode_dirty(inode);
+ dio->completed = size;
+
+ mutex_unlock(&sbi->s_lock);
+ exfat_unlock_isize_folio(folio);
+ return 0;
+ }
+
+ static const struct iomap_dio_ops exfat_write_dio_ops = {
+ .end_io = exfat_file_write_dio_end_io,
+ };
+
+ /*
+ * Run after iomap's post-write invalidation, so gap folios cannot be
+ * mistaken for stale cache pages by the direct I/O completion.
+ */
+ static int exfat_finish_dio_gap(struct exfat_dio *dio)
+ {
+ struct inode *inode = file_inode(dio->iocb.ki_filp);
+ struct exfat_inode_info *ei = EXFAT_I(inode);
+ loff_t start = max(exfat_get_valid_size(ei), exfat_get_zeroed_size(ei));
+ int ret;
+
+ if (exfat_get_valid_size(ei) >= dio->start)
+ return 0;
+ if (start < dio->start) {
+ unmap_mapping_range(inode->i_mapping, start, dio->start - start, 0);
+ ret = iomap_zero_range(inode, start, dio->start - start, NULL,
- &exfat_write_iomap_ops,
++ exfat_write_iomap_next,
+ &exfat_dio_gap_write_ops, dio);
+ if (ret)
+ return ret;
+ }
+ if (exfat_advance_valid_size(ei, dio->start + dio->completed))
+ mark_inode_dirty(inode);
+ return 0;
+ }
+
/*
* The clusters for a write are allocated before the data is copied. Free the
* ones that a failed or short write has left beyond the end of the file.
@@@ -828,12 -973,12 +973,12 @@@ static ssize_t exfat_fallback_buffered_
inode_dio_wait(file_inode(iocb->ki_filp));
- written = iomap_file_buffered_write(iocb, from, exfat_write_iomap_next,
- written = iomap_file_buffered_write(&buffered, &source, &exfat_write_iomap_ops,
- &exfat_iomap_write_ops, NULL);
- if (written <= 0)
++ written = iomap_file_buffered_write(&buffered, &source, exfat_write_iomap_next,
+ NULL, NULL);
+ if (written < 0)
return written;
- end = iocb->ki_pos + written - 1;
+ end = buffered.ki_pos - 1;
ret = filemap_write_and_wait_range(iocb->ki_filp->f_mapping,
offset, end);
if (ret)
@@@ -848,25 -996,101 +996,101 @@@
static ssize_t exfat_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
+ struct inode *inode = file_inode(iocb->ki_filp);
+ struct block_device *bdev = inode->i_sb->s_bdev;
+ struct exfat_dio dio = { };
+ struct iov_iter source = *from;
+ struct iomap_dio *iomap_dio;
+ loff_t old_size = i_size_read(inode);
+ loff_t valid_size = exfat_get_valid_size(EXFAT_I(inode));
+ loff_t end = iocb->ki_pos + iov_iter_count(from);
ssize_t ret;
+ int error;
- ret = iomap_dio_rw(iocb, from, exfat_write_iomap_next,
- &exfat_write_dio_ops, 0, NULL, 0);
- if (ret == -ENOTBLK)
- ret = 0;
- else if (ret < 0)
+ /* VDL extension must wait for outstanding overwrites. */
+ if (end > valid_size)
+ inode_dio_wait(inode);
+ ret = exfat_prepare_dio_range(inode, end);
+ if (ret)
return ret;
- if (iov_iter_count(from)) {
- ssize_t written;
-
- written = exfat_fallback_buffered_write(iocb, from);
- if (written < 0)
- return written;
- ret += written;
+ if (end <= valid_size) {
+ /* Use existing mappings and allow asynchronous completion. */
- ret = iomap_dio_rw(iocb, from, &exfat_iomap_ops, NULL,
++ ret = iomap_dio_rw(iocb, from, exfat_iomap_next, NULL,
+ IOMAP_DIO_OVERWRITE_ONLY, &valid_size, 0);
+ if (ret != -ENOTBLK)
+ return ret;
+ goto buffered;
}
- return ret;
+ kiocb_clone(&dio.iocb, iocb, iocb->ki_filp);
+ dio.start = iocb->ki_pos;
+ /* User page faults can take invalidate_lock via page_mkwrite. */
+ iomap_dio = __iomap_dio_rw(&dio.iocb, &source,
- &exfat_write_iomap_ops,
++ exfat_write_iomap_next,
+ &exfat_write_dio_ops,
+ 0, &dio, 0);
+
+ /* Serialize size updates, post-invalidation and gap completion. */
+ filemap_invalidate_lock(inode->i_mapping);
+ if (IS_ERR_OR_NULL(iomap_dio))
+ ret = PTR_ERR_OR_ZERO(iomap_dio);
+ else
+ ret = iomap_dio_complete(iomap_dio);
+ if (dio.completed) {
+ error = exfat_finish_dio_gap(&dio);
+ if (error) {
+ exfat_err(inode->i_sb,
+ "write: fail to initialize direct I/O gap (%d)",
+ error);
+ if (ret >= 0)
+ ret = error;
+ }
+ }
+ if (ret < 0) {
+ struct exfat_inode_info *ei = EXFAT_I(inode);
+ loff_t size = max(old_size, exfat_get_valid_size(ei));
+ loff_t initialized = max(exfat_get_valid_size(ei), dio.start);
+
+ if (size < i_size_read(inode)) {
+ truncate_setsize(inode, size);
+ exfat_truncate(inode);
+ }
+ /* Failed DIO may have changed the prepared invalid tail. */
+ if (exfat_get_zeroed_size(ei) > initialized)
+ exfat_set_zeroed_size(ei, initialized);
+ }
+ if (exfat_bytes_to_cluster(EXFAT_SB(inode->i_sb),
+ exfat_ondisk_size(inode)) >
+ exfat_bytes_to_cluster_round_up(EXFAT_SB(inode->i_sb),
+ i_size_read(inode)))
+ exfat_truncate(inode);
+ filemap_invalidate_unlock(inode->i_mapping);
+
+ if (ret > 0) {
+ iocb->ki_pos = dio.iocb.ki_pos;
+ iov_iter_advance(from, ret);
+ return ret;
+ }
+ if (ret < 0 && ret != -ENOTBLK)
+ return ret;
+
+ buffered:
+ /* Invalidation can fail before iomap checks alignment. */
+ if (((iocb->ki_pos | iov_iter_count(from)) &
+ (bdev_logical_block_size(bdev) - 1)) ||
+ (iov_iter_alignment(from) & bdev_dma_alignment(bdev)))
+ return -EINVAL;
+ if (user_backed_iter(from) && !from->nofault &&
+ fault_in_iov_iter_readable(from, 1))
+ return -EFAULT;
+ if (iocb->ki_pos > exfat_get_valid_size(EXFAT_I(inode))) {
+ ret = exfat_extend_valid_size(inode, iocb->ki_pos);
+ if (ret)
+ return ret;
+ }
+
+ return exfat_fallback_buffered_write(iocb, from);
}
static ssize_t exfat_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
@@@ -921,7 -1150,8 +1150,8 @@@
*/
inode_dio_wait(inode);
ret = iomap_file_buffered_write(iocb, iter,
- exfat_write_iomap_next, NULL, NULL);
- &exfat_write_iomap_ops, &exfat_iomap_write_ops,
++ exfat_write_iomap_next, &exfat_iomap_write_ops,
+ NULL);
}
if (ret != -EIOCBQUEUED && end > i_size_read(inode))
exfat_write_failed(inode);
@@@ -956,9 -1186,15 +1186,15 @@@ static ssize_t exfat_file_read_iter(str
inode_lock_shared(inode);
if (iocb->ki_flags & IOCB_DIRECT) {
+ /* Snapshot before writeback or destination faults can advance VDL. */
+ loff_t valid_size = exfat_get_valid_size(EXFAT_I(inode));
+
file_accessed(iocb->ki_filp);
- ret = iomap_dio_rw(iocb, iter, &exfat_iomap_ops, NULL, 0,
+ ret = iomap_dio_rw(iocb, iter, exfat_iomap_next, NULL, 0,
- NULL, 0);
+ &valid_size, 0);
+ if (ret >= 0 && iov_iter_count(iter) &&
+ iocb->ki_pos < i_size_read(inode))
+ ret = filemap_read(iocb, iter, ret);
} else {
ret = generic_file_read_iter(iocb, iter);
}
@@@ -971,55 -1207,51 +1207,51 @@@
static vm_fault_t exfat_page_mkwrite(struct vm_fault *vmf)
{
struct inode *inode = file_inode(vmf->vma->vm_file);
+ struct address_space *mapping = inode->i_mapping;
struct exfat_inode_info *ei = EXFAT_I(inode);
+ struct folio *folio = page_folio(vmf->page);
+ loff_t fault_start = folio_pos(folio);
+ loff_t new_valid_size, gap_start;
vm_fault_t ret;
- loff_t new_valid_size, mmap_valid_size, fault_page_start;
+ int error;
- if (!inode_trylock(inode))
- return VM_FAULT_RETRY;
-
- mmap_valid_size = ((loff_t)vmf->pgoff + 1) << PAGE_SHIFT;
- fault_page_start = ((loff_t)vmf->pgoff) << PAGE_SHIFT;
- new_valid_size = min(mmap_valid_size, i_size_read(inode));
-
- if (exfat_get_valid_size(ei) < new_valid_size) {
- loff_t zeroed_size = exfat_get_zeroed_size(ei);
-
- if (zeroed_size < fault_page_start) {
- int err;
-
- /*
- * Zero only the gap below the faulting page. The read
- * fault populated its folio and iomap_page_mkwrite()
- * will dirty it.
- */
- err = exfat_prepare_valid_range(inode, zeroed_size,
- fault_page_start);
- if (err < 0) {
- inode_unlock(inode);
- return vmf_fs_error(err);
- }
- }
-
- /*
- * Track zeroed_size by block, not page, because writeback stops
- * at i_size recording blocks wholly beyond it could skip a
- * later required zeroing.
- */
- exfat_advance_zeroed_size(ei,
- round_up(new_valid_size, i_blocksize(inode)));
- exfat_set_valid_size(ei, new_valid_size);
- mark_inode_dirty(inode);
- }
+ if (unlikely(exfat_forced_shutdown(inode->i_sb)))
+ return VM_FAULT_SIGBUS;
sb_start_pagefault(inode->i_sb);
- file_update_time(vmf->vma->vm_file);
+ error = file_update_time(vmf->vma->vm_file);
+ if (error) {
+ ret = vmf_fs_error(error);
+ goto out_pagefault;
+ }
+ filemap_invalidate_lock_shared(mapping);
+
+ if (folio->mapping != mapping || fault_start >= i_size_read(inode)) {
+ ret = VM_FAULT_NOPAGE;
+ goto out_unlock;
+ }
+
+ /* The faulting folio is already populated; initialize only its gap. */
+ gap_start = max(exfat_get_valid_size(ei), exfat_get_zeroed_size(ei));
+ error = exfat_prepare_range(inode, gap_start, fault_start, true);
+ if (error) {
+ ret = vmf_fs_error(error);
+ goto out_unlock;
+ }
- filemap_invalidate_lock_shared(inode->i_mapping);
- ret = iomap_page_mkwrite(vmf, &exfat_iomap_ops, NULL);
+ ret = iomap_page_mkwrite(vmf, exfat_iomap_next, NULL);
- filemap_invalidate_unlock_shared(inode->i_mapping);
+ if (ret == VM_FAULT_LOCKED) {
+ /* Buffered write may have grown EOF before we locked the folio. */
+ new_valid_size = min(folio_next_pos(folio), i_size_read(inode));
+ exfat_advance_zeroed_size(ei,
+ round_up(new_valid_size, i_blocksize(inode)));
+ if (exfat_advance_valid_size(ei, new_valid_size))
+ mark_inode_dirty(inode);
+ }
+ out_unlock:
+ filemap_invalidate_unlock_shared(mapping);
+ out_pagefault:
sb_end_pagefault(inode->i_sb);
- inode_unlock(inode);
return ret;
}
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
next reply other threads:[~2026-11-18 13:29 UTC|newest]
Thread overview: 3+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 13:29 Mark Brown [this message]
-- strict thread matches above, loose matches on Subject: below --
2026-11-18 13:06 Mark Brown
2026-11-09 12:15 Mark Brown
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=av2oK6fn2XToTjxV@sirena.org.uk \
--to=broonie@kernel.org \
--cc=brauner@kernel.org \
--cc=chizhiling@kylinos.cn \
--cc=joannelkoong@gmail.com \
--cc=linkinjeon@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-next@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
all inboxes | Powered by JetHome®