Implement a replacement for launder_folio[1]. The key feature of invalidate_inode_pages2() is that it locks each folio individually, unmaps it to prevent mmap'd accesses interfering and calls the ->launder_folio() address_space op to flush it. This has problems: firstly, each folio is written individually as one or more small writes; secondly, adjacent folios cannot be added so easily into the laundry; thirdly, it's yet another op to implement. Here's a bit of a hacked together solution which should probably be moved to mm/: Use the mmap lock to cause future faulting to wait, then unmap all the folios if we have mmaps, then, conditionally, use ->writepages() to flush any dirty data back and then discard all pages. The caller needs to hold a lock to prevent ->write_iter() getting underfoot. Note that this does not prevent ->read_iter() from accessing the file whilst we do this since that may operate without locking. We also have the writeback_control available and so have the opportunity to set a flag in it to tell the filesystem that we're doing an invalidation. Signed-off-by: David Howells <dhowells@xxxxxxxxxx> cc: Matthew Wilcox <willy@xxxxxxxxxxxxx> cc: Miklos Szeredi <miklos@xxxxxxxxxx> cc: Trond Myklebust <trond.myklebust@xxxxxxxxxxxxxxx> cc: Christoph Hellwig <hch@xxxxxx> cc: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx> cc: Alexander Viro <viro@xxxxxxxxxxxxxxxxxx> cc: Christian Brauner <brauner@xxxxxxxxxx> cc: Jeff Layton <jlayton@xxxxxxxxxx> cc: linux-mm@xxxxxxxxx cc: linux-fsdevel@xxxxxxxxxxxxxxx cc: netfs@xxxxxxxxxxxxxxx cc: v9fs@xxxxxxxxxxxxxxx cc: linux-afs@xxxxxxxxxxxxxxxxxxx cc: ceph-devel@xxxxxxxxxxxxxxx cc: linux-cifs@xxxxxxxxxxxxxxx cc: linux-nfs@xxxxxxxxxxxxxxx cc: devel@xxxxxxxxxxxxxxxxxx Link: https://lore.kernel.org/r/1668172.1709764777@xxxxxxxxxxxxxxxxxxxxxx/ [1] --- fs/netfs/misc.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 3 ++ mm/memory.c | 3 +- 3 files changed, 61 insertions(+), 1 deletion(-) diff --git a/fs/netfs/misc.c b/fs/netfs/misc.c index bc1fc54fb724..774ce825fbec 100644 --- a/fs/netfs/misc.c +++ b/fs/netfs/misc.c @@ -250,3 +250,59 @@ bool netfs_release_folio(struct folio *folio, gfp_t gfp) return true; } EXPORT_SYMBOL(netfs_release_folio); + +extern void unmap_mapping_range_tree(struct rb_root_cached *root, + pgoff_t first_index, + pgoff_t last_index, + struct zap_details *details); + +/** + * netfs_invalidate_inode - Invalidate/forcibly write back an inode's pagecache + * @inode: The inode to flush + * @flush: Set to write back rather than simply invalidate. + * + * Invalidate all the folios on an inode, possibly writing them back first. + * Whilst the operation is undertaken, the mmap lock is held to prevent + * ->fault() from reinstalling the folios. The caller must hold a lock on the + * inode sufficient to prevent ->write_iter() from dirtying more folios. + */ +int netfs_invalidate_inode(struct inode *inode, bool flush) +{ + struct address_space *mapping = inode->i_mapping; + + if (!mapping || !mapping->nrpages) + goto out; + + /* Prevent folios from being faulted in. */ + i_mmap_lock_write(mapping); + + if (!mapping->nrpages) + goto unlock; + + /* Assume there are probably PTEs only if there are mmaps. */ + if (unlikely(!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root))) { + struct zap_details details = { }; + + unmap_mapping_range_tree(&mapping->i_mmap, 0, LLONG_MAX, &details); + } + + /* Write back the data if we're asked to. */ + if (flush) { + struct writeback_control wbc = { + .sync_mode = WB_SYNC_ALL, + .nr_to_write = LONG_MAX, + .range_start = 0, + .range_end = LLONG_MAX, + }; + + filemap_fdatawrite_wbc(mapping, &wbc); + } + + /* Wait for writeback to complete on all folios and discard. */ + truncate_inode_pages_range(mapping, 0, LLONG_MAX); + +unlock: + i_mmap_unlock_write(mapping); +out: + return filemap_check_errors(mapping); +} diff --git a/include/linux/netfs.h b/include/linux/netfs.h index 298552f5122c..40dc34ee291d 100644 --- a/include/linux/netfs.h +++ b/include/linux/netfs.h @@ -400,6 +400,9 @@ ssize_t netfs_buffered_write_iter_locked(struct kiocb *iocb, struct iov_iter *fr ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from); ssize_t netfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from); +/* High-level invalidation API */ +int netfs_invalidate_inode(struct inode *inode, bool flush); + /* Address operations API */ struct readahead_control; void netfs_readahead(struct readahead_control *); diff --git a/mm/memory.c b/mm/memory.c index f2bc6dd15eb8..106f32c7d7fb 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -3665,7 +3665,7 @@ static void unmap_mapping_range_vma(struct vm_area_struct *vma, zap_page_range_single(vma, start_addr, end_addr - start_addr, details); } -static inline void unmap_mapping_range_tree(struct rb_root_cached *root, +inline void unmap_mapping_range_tree(struct rb_root_cached *root, pgoff_t first_index, pgoff_t last_index, struct zap_details *details) @@ -3685,6 +3685,7 @@ static inline void unmap_mapping_range_tree(struct rb_root_cached *root, details); } } +EXPORT_SYMBOL_GPL(unmap_mapping_range_tree); /** * unmap_mapping_folio() - Unmap single folio from processes.
