Merge tag 'folio-5.19' of git://git.infradead.org/users/willy/pagecache

after which it *has* to look in the cache.

To inform fscache that a page might now be in the cache, the following function

should be called from the ``releasepage`` address space op::

should be called from the ``release_folio`` address space op::

	void fscache_note_page_release(struct fscache_cookie *cookie);

if the page has been released (ie. releasepage returned true).

if the page has been released (ie. release_folio returned true).

Page release and page invalidation should also wait for any mark left on the

page to say that a DIO write is underway from that page::

When inline encryption isn't used, filesystems must encrypt/decrypt

the file contents themselves, as described below:

For the read path (->readpage()) of regular files, filesystems can

For the read path (->read_folio()) of regular files, filesystems can

read the ciphertext into the page cache and decrypt it in-place.  The

page lock must be held until decryption has finished, to prevent the

page from becoming visible to userspace prematurely.

Pagecache

~~~~~~~~~

For filesystems using Linux's pagecache, the ``->readpage()`` and

For filesystems using Linux's pagecache, the ``->read_folio()`` and

``->readahead()`` methods must be modified to verify pages before they

are marked Uptodate.  Merely hooking ``->read_iter()`` would be

insufficient, since ``->read_iter()`` is not used for memory maps.

prototypes::

	int (*writepage)(struct page *page, struct writeback_control *wbc);

	int (*readpage)(struct file *, struct page *);

	int (*read_folio)(struct file *, struct folio *);

	int (*writepages)(struct address_space *, struct writeback_control *);

	bool (*dirty_folio)(struct address_space *, struct folio *folio);

	void (*readahead)(struct readahead_control *);

	int (*write_begin)(struct file *, struct address_space *mapping,

				loff_t pos, unsigned len, unsigned flags,

				loff_t pos, unsigned len,

				struct page **pagep, void **fsdata);

	int (*write_end)(struct file *, struct address_space *mapping,

				loff_t pos, unsigned len, unsigned copied,

				struct page *page, void *fsdata);

	sector_t (*bmap)(struct address_space *, sector_t);

	void (*invalidate_folio) (struct folio *, size_t start, size_t len);

	int (*releasepage) (struct page *, int);

	void (*freepage)(struct page *);

	bool (*release_folio)(struct folio *, gfp_t);

	void (*free_folio)(struct folio *);

	int (*direct_IO)(struct kiocb *, struct iov_iter *iter);

	bool (*isolate_page) (struct page *, isolate_mode_t);

	int (*migratepage)(struct address_space *, struct page *, struct page *);

	int (*swap_deactivate)(struct file *);

locking rules:

	All except dirty_folio and freepage may block

	All except dirty_folio and free_folio may block

======================	======================== =========	===============

ops			PageLocked(page)	 i_rwsem	invalidate_lock

ops			folio locked		 i_rwsem	invalidate_lock

======================	======================== =========	===============

writepage:		yes, unlocks (see below)

readpage:		yes, unlocks				shared

read_folio:		yes, unlocks				shared

writepages:

dirty_folio		maybe

dirty_folio:		maybe

readahead:		yes, unlocks				shared

write_begin:		locks the page		 exclusive

write_end:		yes, unlocks		 exclusive

bmap:

invalidate_folio:	yes					exclusive

releasepage:		yes

freepage:		yes

release_folio:		yes

free_folio:		yes

direct_IO:

isolate_page:		yes

migratepage:		yes (both)

swap_deactivate:	no

======================	======================== =========	===============

->write_begin(), ->write_end() and ->readpage() may be called from

->write_begin(), ->write_end() and ->read_folio() may be called from

the request handler (/dev/loop).

->readpage() unlocks the page, either synchronously or via I/O

->read_folio() unlocks the folio, either synchronously or via I/O

completion.

->readahead() unlocks the pages that I/O is attempted on like ->readpage().

->readahead() unlocks the folios that I/O is attempted on like ->read_folio().

->writepage() is used for two purposes: for "memory cleansing" and for

"sync".  These are quite different operations and the behaviour may differ

path (and thus calling into ->invalidate_folio) to block races between page

cache invalidation and page cache filling functions (fault, read, ...).

->releasepage() is called when the kernel is about to try to drop the

buffers from the page in preparation for freeing it.  It returns zero to

indicate that the buffers are (or may be) freeable.  If ->releasepage is zero,

the kernel assumes that the fs has no private interest in the buffers.

->release_folio() is called when the kernel is about to try to drop the

buffers from the folio in preparation for freeing it.  It returns false to

indicate that the buffers are (or may be) freeable.  If ->release_folio is

NULL, the kernel assumes that the fs has no private interest in the buffers.

->freepage() is called when the kernel is done dropping the page

->free_folio() is called when the kernel has dropped the folio

from the page cache.

->launder_folio() may be called prior to releasing a folio if

Buffered Read Helpers

=====================

The library provides a set of read helpers that handle the ->readpage(),

The library provides a set of read helpers that handle the ->read_folio(),

->readahead() and much of the ->write_begin() VM operations and translate them

into a common call framework.

Three read helpers are provided::

	void netfs_readahead(struct readahead_control *ractl);

	int netfs_readpage(struct file *file,

			   struct page *page);

	int netfs_read_folio(struct file *file,

			   struct folio *folio);

	int netfs_write_begin(struct file *file,

			      struct address_space *mapping,

			      loff_t pos,

			      unsigned int len,

			      unsigned int flags,

			      struct folio **_folio,

			      void **_fsdata);

Each corresponds to a VM address space operation.  These operations use the

state in the per-inode context.

For ->readahead() and ->readpage(), the network filesystem just point directly

For ->readahead() and ->read_folio(), the network filesystem just point directly

at the corresponding read helper; whereas for ->write_begin(), it may be a

little more complicated as the network filesystem might want to flush

conflicting writes or track dirty data and needs to put the acquired folio if