Re: [PATCH v2 1/5] netfs: clear post-EOF pagecache when extending a file via write

[Paulo Alcantara <pc@manguebit.org>]

Matthew Wilcox <willy@infradead.org> writes:

> On Mon, Sep 21, 2026 at 08:07:51PM -0300, Paulo Alcantara wrote:
>> +	int netfs_clear_stale_post_eof(struct inode *inode, unsigned long long from,
>> +				       unsigned long long to, bool nowait);
>
> Should this be uoff_t?  Or even loff_t?

uoff_t.

>
>> +int netfs_clear_stale_post_eof(struct inode *inode, unsigned long long from,
>> +			       unsigned long long to, bool nowait)
>> +{
>> +	struct address_space *mapping = inode->i_mapping;
>> +	fgf_t fgp = FGP_LOCK;
>> +	struct folio *folio;
>> +
>> +	if (from >= to)
>> +		return 0;
>> +
>> +	if (nowait)
>> +		fgp |= FGP_NOWAIT;
>> +
>> +	folio = __filemap_get_folio(mapping, from >> PAGE_SHIFT, fgp, 0);
>> +	if (IS_ERR(folio))
>> +		return PTR_ERR(folio) == -EAGAIN ? -EAGAIN : 0;
>> +
>> +	if (folio_mkclean(folio))
>> +		folio_mark_dirty(folio);
>> +
>> +	if (folio_test_uptodate(folio)) {
>> +		size_t end = umin(to - folio_pos(folio), folio_size(folio));
>> +		size_t offset = offset_in_folio(folio, from);
>> +
>> +		folio_zero_segment(folio, offset, end);
>> +	}
>> +
>> +	folio_unlock(folio);
>> +	folio_put(folio);
>> +	return 0;
>> +}
>> +EXPORT_SYMBOL(netfs_clear_stale_post_eof);
>
> This looks suspiciously similar to pagecache_isize_extended() but does
> not mention it.  So any updates to that function will probably imss this
> one.  That's not great.

True.  Sorry about that.

There are some reasons that I ended up with our own helper:

- The block size checks make no sense for CIFS, as reads and writes will
  be byte aligned.  For instance, CIFS and AFS set block size to >=
  PAGE_SIZE, therefore calling pagecache_isize_extended() is a no-op for
  them.

- netfslib needs to honour NOWAIT, which pagecache_isize_extended()
  can't do due to filemap_lock_folio() and folio_mkclean().  Besides, we
  would also need to return -EAGAIN in case the folio is mapped or under
  writeback.

- netfs_clear_stale_post_eof() will be called before i_size is updated,
  so we re-check i_size after acquiring the folio lock.  It runs with
  i_rwsem held shared in both the buffered and unbuffered/DIO paths, so
  extending writers might concurrently change i_size while we run.
  pagecache_isize_extended() can't also be used as it requires to be
  called after i_size is updated, therefore hitting WARN_ON(to >
  inode->i_size).

NFS also has its own helper (nfs_truncate_last_folio), but couldn't
re-use it due to above reasons.

Please let me know if you have any ideas.

This is what I currently have for new helper (trying to address some
issues found out by sashiko as well):

int netfs_clear_stale_post_eof(struct inode *inode,
			       uoff_t from, uoff_t to, bool nowait)
{
	struct address_space *mapping = inode->i_mapping;
	fgf_t fgp = FGP_LOCK;
	struct folio *folio;
	int ret;

	if (from >= to)
		return 0;

	if (nowait)
		fgp |= FGP_NOWAIT;

	folio = __filemap_get_folio(mapping, from >> PAGE_SHIFT, fgp, 0);
	if (IS_ERR(folio))
		return PTR_ERR(folio) == -EAGAIN ? -EAGAIN : 0;

	ret = 0;
	if (nowait && (folio_mapped(folio) || folio_test_writeback(folio))) {
		ret = -EAGAIN;
		goto out;
	}

	folio_wait_writeback(folio);

	if (folio_mkclean(folio))
		folio_mark_dirty(folio);

	if (folio_test_uptodate(folio)) {
		uoff_t fpos = folio_pos(folio);

		from = umax(from, i_size_read(inode));
		if (from < to && from < fpos + folio_size(folio)) {
			size_t end = umin(to - fpos, folio_size(folio));
			size_t offset = from - fpos;

			folio_zero_segment(folio, offset, end);
		}
	}
out:
	folio_unlock(folio);
	folio_put(folio);
	return ret;
}