mm, netfs, afs: Truncation fixes
Subsystems (10)
David Howells
maintainercover mm, netfs, afs: Truncation fixes
Hi Christian,
Here are some fixes for truncation, netfslib and afs that I discovered whilst trying Pankaj Raghav's minimum folio order patchset:
(1) Fix truncate to make it honour AS_RELEASE_ALWAYS in a couple of places that got missed.
(2) Fix duplicated editing of a partially invalidated folio in afs's post-setattr edit phase.
(3) Fix netfs_release_folio() to indicate that the folio is busy if the folio is dirty (as does iomap).
(4) Fix the trimming of a folio that contain streaming-write data when truncation occurs into or past that folio
The patches can also be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=netfs-fixes
Thanks,
David
David Howells (4):
mm: Fix missing folio invalidation calls during truncation
afs: Fix post-setattr file edit to do truncation correctly
netfs: Fix netfs_release_folio() to say no if folio dirty
netfs: Fix trimming of streaming-write folios in netfs_inval_folio()
fs/afs/inode.c | 11 +++++++--- fs/netfs/misc.c | 53 +++++++++++++++++++++++++++++++++++-------------- mm/truncate.c | 4 ++-- 3 files changed, 48 insertions(+), 20 deletions(-)
David Howells
maintainerPATCH 1/4 mm: Fix missing folio invalidation calls during truncation
When AS_RELEASE_ALWAYS is set on a mapping, the ->release_folio() and ->invalidate_folio() calls should be invoked even if PG_private and PG_private_2 aren't set. This is used by netfslib to keep track of the point above which reads can be skipped in favour of just zeroing pagecache locally.
There are a couple of places in truncation in which invalidation is only called when folio_has_private() is true. Fix these to check folio_needs_release() instead.
Without this, the generic/075 and generic/112 xfstests (both fsx-based tests) fail with minimum folio size patches applied[1].
--- mm/truncate.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
mm/truncate.c +2 -2
@@ -157,7 +157,7 @@ static void truncate_cleanup_folio(struct folio *folio)if (folio_mapped (folio))unmap_mapping_folio (folio); -if (folio_has_private (folio)) +if (folio_needs_release (folio))folio_invalidate (folio,0 ,folio_size (folio));/*
@@ -219,7 +219,7 @@ bool truncate_inode_partial_folio(struct folio *folio, loff_t start, loff_t end)if (!mapping_inaccessible (folio->mapping))folio_zero_range (folio, offset, length); -if (folio_has_private (folio)) +if (folio_needs_release (folio))folio_invalidate (folio, offset, length);if (!folio_test_large (folio))return true;
David Howells
maintainerPATCH 2/4 afs: Fix post-setattr file edit to do truncation correctly
In reply to David HowellsAt the end of an kAFS RPC operation, there is an "edit" phase (originally intended for post-directory modification ops to edit the local image) that the setattr VFS op uses to fix up the pagecache if the RPC that requested truncation of a file was successful.
afs_setattr_edit_file() calls truncate_setsize() which sets i_size, expands the pagecache if needed and truncates the pagecache. The first two of those, however, are redundant as they've already been done by afs_setattr_success() under the io_lock and the first is also done under the callback lock (cb_lock).
Fix afs_setattr_edit_file() to call truncate_pagecache() instead (which is called by truncate_setsize(), thereby skipping the redundant parts.
--- fs/afs/inode.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
fs/afs/inode.c +8 -3
@@ -695,13 +695,18 @@ static void afs_setattr_edit_file(struct afs_operation *op) {struct afs_vnode_param *vp = &op->file[0 ];struct afs_vnode *vnode = vp->vnode; +struct inode *inode = &vnode->netfs.inode;if (op->setattr.attr->ia_valid &ATTR_SIZE ) {loff_t size = op->setattr.attr->ia_size; -loff_t i_size = op->setattr.old_i_size; +loff_t old = op->setattr.old_i_size; + +/* Note: inode->i_size was updated by afs_apply_status() inside +* the I/O and callback locks. +*/ -if (size != i_size) { -truncate_setsize (&vnode->netfs.inode, size); +if (size != old) { +truncate_pagecache (inode, size);netfs_resize_file (&vnode->netfs, size, true);fscache_resize_cookie (afs_vnode_cache (vnode), size); }
David Howells
maintainerPATCH 3/4 netfs: Fix netfs_release_folio() to say no if folio dirty
In reply to David HowellsFix netfs_release_folio() to say no (ie. return false) if the folio is dirty (analogous with iomap's behaviour). Without this, it will say yes to the release of a dirty page by split_huge_page_to_list_to_order(), which will result in the loss of untruncated data in the folio.
Without this, the generic/075 and generic/112 xfstests (both fsx-based tests) fail with minimum folio size patches applied[1].
--- fs/netfs/misc.c | 3 +++ 1 file changed, 3 insertions(+)
fs/netfs/misc.c +3 -0
@@ -161,6 +161,9 @@ bool netfs_release_folio(struct folio *folio, gfp_t gfp)struct netfs_inode *ctx =netfs_inode (folio_inode (folio));unsigned long long end; +if (folio_test_dirty (folio)) +return false; + end =folio_pos (folio) +folio_size (folio);if (end > ctx->zero_point) ctx->zero_point = end;
David Howells
maintainerPATCH 4/4 netfs: Fix trimming of streaming-write folios in netfs_inval_folio()
In reply to David HowellsWhen netfslib writes to a folio that it doesn't have data for, but that data exists on the server, it will make a 'streaming write' whereby it stores data in a folio that is marked dirty, but not uptodate. When it does this, it attaches a record to folio->private to track the dirty region.
When truncate() or fallocate() wants to invalidate part of such a folio, it will call into ->invalidate_folio(), specifying the part of the folio that is to be invalidated. netfs_invalidate_folio(), on behalf of the filesystem, must then determine how to trim the streaming write record. In a couple of cases, however, it does this incorrectly (the reduce-length and move-start cases are switched over and don't, in any case, calculate the value correctly).
Fix this by making the logic tree more obvious and fixing the cases.
--- fs/netfs/misc.c | 50 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 35 insertions(+), 15 deletions(-)
fs/netfs/misc.c +35 -15
@@ -97,10 +97,20 @@ EXPORT_SYMBOL(netfs_clear_inode_writeback);void netfs_invalidate_folio (struct folio *folio,size_t offset,size_t length) {struct netfs_folio *finfo; +struct netfs_inode *ctx =netfs_inode (folio_inode (folio));size_t flen =folio_size (folio);_enter ("{%lx},%zx,%zx" , folio->index, offset, length); +if (offset ==0 && length == flen) { +unsigned long long i_size =i_size_read (&ctx->inode); +unsigned long long fpos =folio_pos (folio), end; + + end =umin (fpos + flen, i_size); +if (fpos < i_size && end > ctx->zero_point) + ctx->zero_point = end; + } +folio_wait_private_2 (folio);/* [DEPRECATED] */ if (!folio_test_private (folio))
@@ -115,18 +125,34 @@ void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)/* We have a partially uptodate page from a streaming write. */ unsigned int fstart = finfo->dirty_offset;unsigned int fend = fstart + finfo->dirty_len; -unsigned int end = offset + length; +unsigned int iend = offset + length;if (offset >= fend)return ; -if (end <= fstart) +if (iend <= fstart) +return ; + +/* The invalidation region overlaps the data. If the region +* covers the start of the data, we either move along the start +* or just erase the data entirely. +*/ +if (offset <= fstart) { +if (iend >= fend) + goto erase_completely; +/* Move the start of the data. */ + finfo->dirty_len = fend - iend; + finfo->dirty_offset = offset; +return ; + } + +/* Reduce the length of the data if the invalidation region +* covers the tail part. +*/ +if (iend >= fend) { + finfo->dirty_len = offset - fstart;return ; -if (offset <= fstart && end >= fend) - goto erase_completely; -if (offset <= fstart && end > fstart) - goto reduce_len; -if (offset > fstart && end >= fend) - goto move_start; + } +/* A partial write was split. The caller has already zeroed * it, so just absorb the hole. */
@@ -139,12 +165,6 @@ void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)folio_clear_uptodate (folio);kfree (finfo);return ; -reduce_len: - finfo->dirty_len = offset + length - finfo->dirty_offset; -return ; -move_start: - finfo->dirty_len -= offset - finfo->dirty_offset; - finfo->dirty_offset = offset; }EXPORT_SYMBOL (netfs_invalidate_folio);
@@ -164,7 +184,7 @@ bool netfs_release_folio(struct folio *folio, gfp_t gfp)if (folio_test_dirty (folio))return false; - end =folio_pos (folio) +folio_size (folio); + end =umin (folio_pos (folio) +folio_size (folio),i_size_read (&ctx->inode));if (end > ctx->zero_point) ctx->zero_point = end;