mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* linux-next: manual merge of the exfat tree with the origin tree
@ 2026-11-18 13:29 Mark Brown
  0 siblings, 0 replies; 3+ messages in thread
From: Mark Brown @ 2026-11-18 13:29 UTC (permalink / raw)
  To: Namjae Jeon
  Cc: Chi Zhiling, Christian Brauner, Joanne Koong,
	Linux Kernel Mailing List, Linux Next Mailing List

[-- 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 --]

^ permalink raw reply	[flat|nested] 3+ messages in thread
* linux-next: manual merge of the exfat tree with the origin tree
@ 2026-11-18 13:06 Mark Brown
  0 siblings, 0 replies; 3+ messages in thread
From: Mark Brown @ 2026-11-18 13:06 UTC (permalink / raw)
  To: Namjae Jeon
  Cc: Chi Zhiling, Christian Brauner, Joanne Koong,
	Linux Kernel Mailing List, Linux Next Mailing List

[-- Attachment #1: Type: text/plain, Size: 9792 bytes --]

Hi all,

Today's linux-next merge of the exfat tree got conflicts in:

  fs/exfat/iomap.h
  fs/exfat/iomap.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")

from the exfat tree.  This really needs 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/iomap.c
index 4e6f3ed9dcc85,5e2c35954ecd3..0000000000000
--- a/fs/exfat/iomap.c
+++ b/fs/exfat/iomap.c
@@@ -151,40 -158,44 +158,40 @@@ out
  	return err;
  }
  
- static int exfat_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
- 		unsigned int flags, struct iomap *iomap, struct iomap *srcmap)
 -static int exfat_iomap_next(const struct iomap_iter *iter,
 -			   struct iomap *iomap, struct iomap *srcmap)
++int exfat_iomap_next(const struct iomap_iter *iter,
++		     struct iomap *iomap, struct iomap *srcmap)
  {
- 	return __exfat_iomap_begin(inode, offset, length, flags, iomap, false);
+ 	const loff_t *dio_valid_size = iter->private;
+ 	loff_t valid_size;
+ 	int ret;
+ 
+ 	if (iomap->length) {
+ 		ret = iomap_iter_continue(iter, iomap, srcmap, 0);
+ 		if (ret <= 0)
+ 			return ret;
+ 	}
+ 	if (iter->flags & IOMAP_DIRECT)
+ 		valid_size = *dio_valid_size;
+ 	else
+ 		valid_size = exfat_get_valid_size(EXFAT_I(iter->inode));
+ 	ret = __exfat_iomap_begin(iter->inode, iter->pos, iter->len,
 -				 iter->flags, iomap, false, valid_size);
++				  iter->flags, iomap, false, valid_size);
+ 	return ret ?: 1;
  }
  
  static int exfat_write_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
  		unsigned int flags, struct iomap *iomap, struct iomap *srcmap)
  {
- 	struct exfat_inode_info *ei = EXFAT_I(inode);
- 	loff_t valid_size = exfat_get_valid_size(ei);
- 	loff_t end;
- 	int err;
+ 	int ret;
  
- 	err = __exfat_iomap_begin(inode, offset, length, flags, iomap, true);
- 	if (err || flags & (IOMAP_DIRECT | IOMAP_FAULT) ||
- 	    iomap->flags & IOMAP_F_NEW)
- 		return err;
- 
- 	end = iomap->offset + iomap->length;
- 	if (end >= valid_size ||
- 	    round_up(end, i_blocksize(inode)) <= valid_size)
- 		return 0;
- 
- 	/*
- 	 * Zero the invalid bytes from valid_size to the end of the block
- 	 * to prevent stale data from being exposed through the page cache.
- 	 */
- 	return iomap_truncate_page(inode, valid_size, NULL, exfat_iomap_next,
- 				   NULL, NULL);
+ 	ret = __exfat_iomap_begin(inode, offset, length, flags, iomap, true,
+ 				  exfat_get_valid_size(EXFAT_I(inode)));
+ 	if (!ret && (flags & IOMAP_DIRECT) &&
+ 	    offset + iomap->length > iomap->validity_cookie)
+ 		iomap->flags |= IOMAP_F_DIRTY;
+ 	return ret;
  }
  
- DEFINE_IOMAP_ITER_NEXT(exfat_iomap_next, exfat_iomap_begin);
 -const struct iomap_ops exfat_iomap_ops = {
 -	.iomap_next = exfat_iomap_next,
 -};
--
  #ifdef CONFIG_SWAP
  static int exfat_swap_iomap_begin(struct inode *inode, loff_t offset,
  		loff_t length, unsigned int flags, struct iomap *iomap,
@@@ -214,31 -227,155 +219,150 @@@ static int exfat_write_iomap_end(struc
  	if (!written)
  		return 0;
  
- 	end = pos + written;
- 
- 	if (exfat_advance_valid_size(ei, end))
- 		dirtied = true;
- 
- 	/*
- 	 * IOMAP_F_ZERO_TAIL zeroes the remainder of the last block. Track that
- 	 * block as zeroed so later valid_size extensions do not zero it again.
- 	 */
- 	if (iomap->flags & IOMAP_F_ZERO_TAIL)
- 		end = round_up(end, i_blocksize(inode));
- 	exfat_advance_zeroed_size(ei, end);
- 
- 	if (dirtied || iomap->flags & IOMAP_F_SIZE_CHANGED)
+ 	if (iomap->flags & IOMAP_F_SIZE_CHANGED)
  		mark_inode_dirty(inode);
--
  	return written;
  }
  
- DEFINE_IOMAP_ITER_NEXT_END(exfat_write_iomap_next, exfat_write_iomap_begin,
- 		exfat_write_iomap_end);
 -static int exfat_write_iomap_next(const struct iomap_iter *iter,
 -				  struct iomap *iomap, struct iomap *srcmap)
++int exfat_write_iomap_next(const struct iomap_iter *iter,
++			   struct iomap *iomap, struct iomap *srcmap)
+ {
+ 	int ret;
+ 
+ 	ret = iomap_iter_next(iter, iomap, srcmap, exfat_write_iomap_begin,
+ 			      exfat_write_iomap_end);
+ 	if (ret == -ENOSPC && (iter->flags & IOMAP_DIRECT)) {
+ 		const struct exfat_dio *dio = iter->private;
+ 
+ 		/*
+ 		 * ENOTBLK makes iomap wait for the submitted bios and report
+ 		 * a short write only if they succeeded.
+ 		 */
+ 		if (iter->pos > dio->start)
+ 			return -ENOTBLK;
+ 	}
+ 
+ 	return ret;
+ }
+ 
 -const struct iomap_ops exfat_write_iomap_ops = {
 -	.iomap_next	= exfat_write_iomap_next,
 -};
 -
+ static void exfat_zero_invalid_range(struct folio *folio, loff_t pos,
+ 				     size_t len, loff_t valid_size)
+ {
+ 	loff_t start = max(pos, valid_size);
+ 
+ 	if (start < pos + len)
+ 		folio_zero_segment(folio, offset_in_folio(folio, start),
+ 				   offset_in_folio(folio, pos) + len);
+ }
+ 
+ static struct folio *exfat_iomap_get_folio(struct iomap_iter *iter, loff_t pos,
+ 					   unsigned int len)
+ {
+ 	struct folio *folio = iomap_get_folio(iter, pos, len);
+ 
+ 	if (!IS_ERR(folio))
+ 		iter->iomap.private = folio;
+ 	return folio;
+ }
+ 
+ static bool exfat_iomap_valid(struct inode *inode, const struct iomap *iomap)
+ {
+ 	struct folio *folio = iomap->private;
+ 	loff_t valid_size = exfat_get_valid_size(EXFAT_I(inode));
+ 	loff_t old_valid_size = iomap->validity_cookie;
+ 
+ 	if (valid_size == old_valid_size)
+ 		return true;
+ 	if (!folio)
+ 		return false;
+ 
+ 	return old_valid_size >= folio_next_pos(folio) ||
+ 		valid_size <= folio_pos(folio);
+ }
+ 
+ /* Called after iomap_valid(), with the destination folio still locked. */
+ static int exfat_iomap_read_folio_range(const struct iomap_iter *iter,
+ 					struct folio *folio, loff_t pos, size_t len)
+ {
+ 	loff_t valid_size = iter->iomap.validity_cookie;
+ 	int error = 0;
+ 
+ 	if (pos < valid_size)
+ 		error = iomap_bio_read_folio_range_sync(iter, folio, pos, len);
+ 
+ 	/*
+ 	 * Sanitize all invalid bytes before iomap marks this range uptodate,
+ 	 * including bytes that a short user copy may leave untouched.
+ 	 */
+ 	if (!error)
+ 		exfat_zero_invalid_range(folio, pos, len, valid_size);
+ 	return error;
+ }
+ 
+ static void exfat_iomap_put_folio(struct inode *inode, loff_t pos,
+ 				  unsigned int copied, struct folio *folio)
+ {
+ 	if (copied) {
+ 		struct exfat_inode_info *ei = EXFAT_I(inode);
+ 
+ 		if (exfat_advance_valid_size(ei, pos + copied))
+ 			mark_inode_dirty(inode);
+ 		exfat_advance_zeroed_size(ei,
+ 					  round_up(pos + copied, i_blocksize(inode)));
+ 	}
+ 
+ 	folio_unlock(folio);
+ 	folio_put(folio);
+ }
+ 
+ const struct iomap_write_ops exfat_iomap_write_ops = {
+ 	.get_folio	= exfat_iomap_get_folio,
+ 	.put_folio	= exfat_iomap_put_folio,
+ 	.iomap_valid	= exfat_iomap_valid,
+ 	.read_folio_range = exfat_iomap_read_folio_range,
+ };
+ 
+ /*
+  * Gap zeroing follows the direct write. Keep completed data intact when the
+  * gap and the write share a filesystem block.
+  */
+ static int exfat_dio_gap_read_folio_range(const struct iomap_iter *iter,
+ 		struct folio *folio, loff_t pos, size_t len)
+ {
+ 	const struct exfat_dio *dio = iter->private;
+ 	loff_t valid = iter->iomap.validity_cookie;
+ 	loff_t end = pos + len;
+ 	loff_t start, stop;
+ 	int error;
+ 
+ 	if (pos < valid || end > dio->start) {
+ 		error = iomap_bio_read_folio_range_sync(iter, folio, pos, len);
+ 		if (error)
+ 			return error;
+ 	} else {
+ 		folio_zero_range(folio, offset_in_folio(folio, pos), len);
+ 		return 0;
+ 	}
+ 
+ 	start = max(pos, valid);
+ 	stop = min(end, dio->start);
+ 	if (start < stop)
+ 		folio_zero_segment(folio, offset_in_folio(folio, start),
+ 				   offset_in_folio(folio, pos) + stop - pos);
+ 
+ 	start = max(pos, dio->start + dio->completed);
+ 	if (start < end)
+ 		folio_zero_segment(folio, offset_in_folio(folio, start),
+ 				   offset_in_folio(folio, pos) + len);
+ 	return 0;
+ }
+ 
+ const struct iomap_write_ops exfat_dio_gap_write_ops = {
+ 	.get_folio	= exfat_iomap_get_folio,
+ 	.put_folio	= exfat_iomap_put_folio,
+ 	.iomap_valid	= exfat_iomap_valid,
+ 	.read_folio_range = exfat_dio_gap_read_folio_range,
+ };
  
  /*
   * exfat_writeback_range - Map folio during writeback
diff --cc fs/exfat/iomap.h
index 519132367b65e,f8f018f87230a..0000000000000
--- a/fs/exfat/iomap.h
+++ b/fs/exfat/iomap.h
@@@ -6,11 -6,17 +6,19 @@@
  #ifndef _LINUX_EXFAT_IOMAP_H
  #define _LINUX_EXFAT_IOMAP_H
  
 +#include <linux/iomap.h>
 +
- extern const struct iomap_dio_ops exfat_write_dio_ops;
+ /* One synchronous attempt for a direct write extending valid_size. */
+ struct exfat_dio {
+ 	struct kiocb iocb;
+ 	loff_t start;
+ 	loff_t completed;
+ };
+ 
 -extern const struct iomap_ops exfat_iomap_ops;
 -extern const struct iomap_ops exfat_write_iomap_ops;
 +DECLARE_IOMAP_ITER_NEXT(exfat_iomap_next);
 +DECLARE_IOMAP_ITER_NEXT(exfat_write_iomap_next);
+ extern const struct iomap_write_ops exfat_iomap_write_ops;
+ extern const struct iomap_write_ops exfat_dio_gap_write_ops;
  extern const struct iomap_writeback_ops exfat_writeback_ops;
  extern const struct iomap_read_ops exfat_iomap_bio_read_ops;
  

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 3+ messages in thread
* linux-next: manual merge of the exfat tree with the origin tree
@ 2026-11-09 12:15 Mark Brown
  0 siblings, 0 replies; 3+ messages in thread
From: Mark Brown @ 2026-11-09 12:15 UTC (permalink / raw)
  To: Namjae Jeon
  Cc: Kees Cook, Kees Cook, Linux Kernel Mailing List,
	Linux Next Mailing List, Reid Downing

[-- Attachment #1: Type: text/plain, Size: 1324 bytes --]

Hi all,

Today's linux-next merge of the exfat tree got a conflict in:

  fs/exfat/nls.c

between commit:

  0af298e62e5cf ("treewide: refresh kmalloc_obj() conversions")

from the origin tree and commit:

  6a221c33aa528 ("exfat: validate upcase table bounds and length")

from the exfat tree.

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/nls.c
index 47aa187c54ccc,bec4d9e5e5bd9..0000000000000
--- a/fs/exfat/nls.c
+++ b/fs/exfat/nls.c
@@@ -655,7 -655,14 +655,14 @@@ static int exfat_load_upcase_table(stru
  	unsigned char skip = false;
  	unsigned short *upcase_table;
  
+ 	if (!tbl_size || (tbl_size & 1)) {
+ 		exfat_fs_error(sb,
+ 			       "bad upcase table size (%llu bytes). Please run fsck",
+ 			       tbl_size);
+ 		return -EINVAL;
+ 	}
+ 
 -	upcase_table = kvcalloc(UTBL_COUNT, sizeof(unsigned short), GFP_KERNEL);
 +	upcase_table = kvzalloc_objs(unsigned short, UTBL_COUNT);
  	if (!upcase_table)
  		return -ENOMEM;
  

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]

^ permalink raw reply	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2026-11-18 13:29 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-18 13:29 linux-next: manual merge of the exfat tree with the origin tree Mark Brown
  -- strict thread matches above, loose matches on Subject: below --
2026-11-18 13:06 Mark Brown
2026-11-09 12:15 Mark Brown

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®