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; }