[PATCH v3 13/20] netfs: Add a netfs inode context

Jeff Layton jlayton at kernel.org
Thu Mar 10 09:52:16 PST 2022


On Thu, 2022-03-10 at 16:18 +0000, David Howells wrote:
> Add a netfs_i_context struct that should be included in the network
> filesystem's own inode struct wrapper, directly after the VFS's inode
> struct, e.g.:
> 
> 	struct my_inode {
> 		struct {
> 			/* These must be contiguous */
> 			struct inode		vfs_inode;
> 			struct netfs_i_context	netfs_ctx;
> 		};
> 	};
> 
> The netfs_i_context struct so far contains a single field for the network
> filesystem to use - the cache cookie:
> 
> 	struct netfs_i_context {
> 		...
> 		struct fscache_cookie	*cache;
> 	};
> 
> Three functions are provided to help with this:
> 
>  (1) void netfs_i_context_init(struct inode *inode,
> 			       const struct netfs_request_ops *ops);
> 
>      Initialise the netfs context and set the operations.
> 
>  (2) struct netfs_i_context *netfs_i_context(struct inode *inode);
> 
>      Find the netfs context from the VFS inode.
> 
>  (3) struct inode *netfs_inode(struct netfs_i_context *ctx);
> 
>      Find the VFS inode from the netfs context.
> 
> Changes
> =======
> ver #3)
>  - Split out the bit to move ceph cap-getting on readahead into
>    ceph_init_request()[1].
>  - Stick in a comment to the netfs inode structs indicating the contiguity
>    requirements[2].
> 
> ver #2)
>  - Adjust documentation to match.
>  - Use "#if IS_ENABLED()" in netfs_i_cookie(), not "#ifdef".
>  - Move the cap check from ceph_readahead() to ceph_init_request() to be
>    called from netfslib.
>  - Remove ceph_readahead() and use  netfs_readahead() directly instead.
> 
> Signed-off-by: David Howells <dhowells at redhat.com>
> cc: linux-cachefs at redhat.com
> Link: https://lore.kernel.org/r/8af0d47f17d89c06bbf602496dd845f2b0bf25b3.camel@kernel.org/ [1]
> Link: https://lore.kernel.org/r/beaf4f6a6c2575ed489adb14b257253c868f9a5c.camel@kernel.org/ [2]
> Link: https://lore.kernel.org/r/164622984545.3564931.15691742939278418580.stgit@warthog.procyon.org.uk/ # v1
> Link: https://lore.kernel.org/r/164678213320.1200972.16807551936267647470.stgit@warthog.procyon.org.uk/ # v2
> ---
> 
>  Documentation/filesystems/netfs_library.rst |  101 +++++++++++++++++++--------
>  fs/9p/cache.c                               |   10 +--
>  fs/9p/v9fs.c                                |    4 -
>  fs/9p/v9fs.h                                |   13 ++-
>  fs/9p/vfs_addr.c                            |   43 +----------
>  fs/9p/vfs_inode.c                           |   13 +++
>  fs/afs/dynroot.c                            |    1 
>  fs/afs/file.c                               |   26 +------
>  fs/afs/inode.c                              |   31 +++++---
>  fs/afs/internal.h                           |   19 ++++-
>  fs/afs/super.c                              |    4 -
>  fs/afs/write.c                              |    3 -
>  fs/ceph/addr.c                              |   31 +-------
>  fs/ceph/cache.c                             |   28 ++++---
>  fs/ceph/cache.h                             |   11 ---
>  fs/ceph/inode.c                             |    6 +-
>  fs/ceph/super.h                             |   17 ++---
>  fs/cifs/cifsglob.h                          |   10 ++-
>  fs/cifs/fscache.c                           |   11 ++-
>  fs/cifs/fscache.h                           |    2 -
>  fs/netfs/internal.h                         |   17 ++++-
>  fs/netfs/objects.c                          |   12 ++-
>  fs/netfs/read_helper.c                      |  100 ++++++++++++---------------
>  fs/netfs/stats.c                            |    1 
>  include/linux/netfs.h                       |   81 +++++++++++++++++++---
>  25 files changed, 317 insertions(+), 278 deletions(-)
> 
> diff --git a/Documentation/filesystems/netfs_library.rst b/Documentation/filesystems/netfs_library.rst
> index 4eb7e7b7b0fc..9c8bc5666b46 100644
> --- a/Documentation/filesystems/netfs_library.rst
> +++ b/Documentation/filesystems/netfs_library.rst
> @@ -7,6 +7,8 @@ Network Filesystem Helper Library
>  .. Contents:
>  
>   - Overview.
> + - Per-inode context.
> +   - Inode context helper functions.
>   - Buffered read helpers.
>     - Read helper functions.
>     - Read helper structures.
> @@ -28,6 +30,69 @@ Note that the library module doesn't link against local caching directly, so
>  access must be provided by the netfs.
>  
>  
> +Per-Inode Context
> +=================
> +
> +The network filesystem helper library needs a place to store a bit of state for
> +its use on each netfs inode it is helping to manage.  To this end, a context
> +structure is defined::
> +
> +	struct netfs_i_context {
> +		const struct netfs_request_ops *ops;
> +		struct fscache_cookie	*cache;
> +	};
> +
> +A network filesystem that wants to use netfs lib must place one of these
> +directly after the VFS ``struct inode`` it allocates, usually as part of its
> +own struct.  This can be done in a way similar to the following::
> +
> +	struct my_inode {
> +		struct {
> +			/* These must be contiguous */
> +			struct inode		vfs_inode;
> +			struct netfs_i_context  netfs_ctx;
> +		};
> +		...
> +	};
> +
> +This allows netfslib to find its state by simple offset from the inode pointer,
> +thereby allowing the netfslib helper functions to be pointed to directly by the
> +VFS/VM operation tables.
> +
> +The structure contains the following fields:
> +
> + * ``ops``
> +
> +   The set of operations provided by the network filesystem to netfslib.
> +
> + * ``cache``
> +
> +   Local caching cookie, or NULL if no caching is enabled.  This field does not
> +   exist if fscache is disabled.
> +
> +
> +Inode Context Helper Functions
> +------------------------------
> +
> +To help deal with the per-inode context, a number helper functions are
> +provided.  Firstly, a function to perform basic initialisation on a context and
> +set the operations table pointer::
> +
> +	void netfs_i_context_init(struct inode *inode,
> +				  const struct netfs_request_ops *ops);
> +
> +then two functions to cast between the VFS inode structure and the netfs
> +context::
> +
> +	struct netfs_i_context *netfs_i_context(struct inode *inode);
> +	struct inode *netfs_inode(struct netfs_i_context *ctx);
> +
> +and finally, a function to get the cache cookie pointer from the context
> +attached to an inode (or NULL if fscache is disabled)::
> +
> +	struct fscache_cookie *netfs_i_cookie(struct inode *inode);
> +
> +
>  Buffered Read Helpers
>  =====================
>  
> @@ -70,38 +135,22 @@ Read Helper Functions
>  
>  Three read helpers are provided::
>  
> -	void netfs_readahead(struct readahead_control *ractl,
> -			     const struct netfs_request_ops *ops,
> -			     void *netfs_priv);
> +	void netfs_readahead(struct readahead_control *ractl);
>  	int netfs_readpage(struct file *file,
> -			   struct folio *folio,
> -			   const struct netfs_request_ops *ops,
> -			   void *netfs_priv);
> +			   struct page *page);
>  	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,
> -			      const struct netfs_request_ops *ops,
> -			      void *netfs_priv);
> -
> -Each corresponds to a VM operation, with the addition of a couple of parameters
> -for the use of the read helpers:
> +			      void **_fsdata);
>  
> - * ``ops``
> -
> -   A table of operations through which the helpers can talk to the filesystem.
> -
> - * ``netfs_priv``
> +Each corresponds to a VM address space operation.  These operations use the
> +state in the per-inode context.
>  
> -   Filesystem private data (can be NULL).
> -
> -Both of these values will be stored into the read request structure.
> -
> -For ->readahead() and ->readpage(), the network filesystem should just jump
> -into the corresponding read helper; whereas for ->write_begin(), it may be a
> +For ->readahead() and ->readpage(), 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
>  an error occurs after calling the helper.
> @@ -246,7 +295,6 @@ through which it can issue requests and negotiate::
>  
>  	struct netfs_request_ops {
>  		void (*init_request)(struct netfs_io_request *rreq, struct file *file);
> -		bool (*is_cache_enabled)(struct inode *inode);
>  		int (*begin_cache_operation)(struct netfs_io_request *rreq);
>  		void (*expand_readahead)(struct netfs_io_request *rreq);
>  		bool (*clamp_length)(struct netfs_io_subrequest *subreq);
> @@ -265,11 +313,6 @@ The operations are as follows:
>     [Optional] This is called to initialise the request structure.  It is given
>     the file for reference and can modify the ->netfs_priv value.
>  
> - * ``is_cache_enabled()``
> -
> -   [Required] This is called by netfs_write_begin() to ask if the file is being
> -   cached.  It should return true if it is being cached and false otherwise.
> -
>   * ``begin_cache_operation()``
>  
>     [Optional] This is called to ask the network filesystem to call into the
> diff --git a/fs/9p/cache.c b/fs/9p/cache.c
> index 55e108e5e133..1c8dc696d516 100644
> --- a/fs/9p/cache.c
> +++ b/fs/9p/cache.c
> @@ -49,22 +49,20 @@ int v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses,
>  
>  void v9fs_cache_inode_get_cookie(struct inode *inode)
>  {
> -	struct v9fs_inode *v9inode;
> +	struct v9fs_inode *v9inode = V9FS_I(inode);
>  	struct v9fs_session_info *v9ses;
>  	__le32 version;
>  	__le64 path;
>  
>  	if (!S_ISREG(inode->i_mode))
>  		return;
> -
> -	v9inode = V9FS_I(inode);
> -	if (WARN_ON(v9inode->fscache))
> +	if (WARN_ON(v9fs_inode_cookie(v9inode)))
>  		return;
>  
>  	version = cpu_to_le32(v9inode->qid.version);
>  	path = cpu_to_le64(v9inode->qid.path);
>  	v9ses = v9fs_inode2v9ses(inode);
> -	v9inode->fscache =
> +	v9inode->netfs_ctx.cache =
>  		fscache_acquire_cookie(v9fs_session_cache(v9ses),
>  				       0,
>  				       &path, sizeof(path),
> @@ -72,5 +70,5 @@ void v9fs_cache_inode_get_cookie(struct inode *inode)
>  				       i_size_read(&v9inode->vfs_inode));
>  
>  	p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",
> -		 inode, v9inode->fscache);
> +		 inode, v9fs_inode_cookie(v9inode));
>  }
> diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
> index 08f65c40af4f..e28ddf763b3b 100644
> --- a/fs/9p/v9fs.c
> +++ b/fs/9p/v9fs.c
> @@ -623,9 +623,7 @@ static void v9fs_sysfs_cleanup(void)
>  static void v9fs_inode_init_once(void *foo)
>  {
>  	struct v9fs_inode *v9inode = (struct v9fs_inode *)foo;
> -#ifdef CONFIG_9P_FSCACHE
> -	v9inode->fscache = NULL;
> -#endif
> +
>  	memset(&v9inode->qid, 0, sizeof(v9inode->qid));
>  	inode_init_once(&v9inode->vfs_inode);
>  }
> diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
> index bc8b30205d36..ec0e8df3b2eb 100644
> --- a/fs/9p/v9fs.h
> +++ b/fs/9p/v9fs.h
> @@ -9,6 +9,7 @@
>  #define FS_9P_V9FS_H
>  
>  #include <linux/backing-dev.h>
> +#include <linux/netfs.h>
>  
>  /**
>   * enum p9_session_flags - option flags for each 9P session
> @@ -108,14 +109,15 @@ struct v9fs_session_info {
>  #define V9FS_INO_INVALID_ATTR 0x01
>  
>  struct v9fs_inode {
> -#ifdef CONFIG_9P_FSCACHE
> -	struct fscache_cookie *fscache;
> -#endif
> +	struct {
> +		/* These must be contiguous */
> +		struct inode	vfs_inode;	/* the VFS's inode record */
> +		struct netfs_i_context netfs_ctx; /* Netfslib context */
> +	};
>  	struct p9_qid qid;
>  	unsigned int cache_validity;
>  	struct p9_fid *writeback_fid;
>  	struct mutex v_mutex;
> -	struct inode vfs_inode;
>  };
>  
>  static inline struct v9fs_inode *V9FS_I(const struct inode *inode)
> @@ -126,7 +128,7 @@ static inline struct v9fs_inode *V9FS_I(const struct inode *inode)
>  static inline struct fscache_cookie *v9fs_inode_cookie(struct v9fs_inode *v9inode)
>  {
>  #ifdef CONFIG_9P_FSCACHE
> -	return v9inode->fscache;
> +	return netfs_i_cookie(&v9inode->vfs_inode);
>  #else
>  	return NULL;
>  #endif
> @@ -163,6 +165,7 @@ extern struct inode *v9fs_inode_from_fid(struct v9fs_session_info *v9ses,
>  extern const struct inode_operations v9fs_dir_inode_operations_dotl;
>  extern const struct inode_operations v9fs_file_inode_operations_dotl;
>  extern const struct inode_operations v9fs_symlink_inode_operations_dotl;
> +extern const struct netfs_request_ops v9fs_req_ops;
>  extern struct inode *v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses,
>  					      struct p9_fid *fid,
>  					      struct super_block *sb, int new);
> diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
> index 91d3926c9559..ed06f3c34e98 100644
> --- a/fs/9p/vfs_addr.c
> +++ b/fs/9p/vfs_addr.c
> @@ -77,17 +77,6 @@ static void v9fs_req_cleanup(struct address_space *mapping, void *priv)
>  	p9_client_clunk(fid);
>  }
>  
> -/**
> - * v9fs_is_cache_enabled - Determine if caching is enabled for an inode
> - * @inode: The inode to check
> - */
> -static bool v9fs_is_cache_enabled(struct inode *inode)
> -{
> -	struct fscache_cookie *cookie = v9fs_inode_cookie(V9FS_I(inode));
> -
> -	return fscache_cookie_enabled(cookie) && cookie->cache_priv;
> -}
> -
>  /**
>   * v9fs_begin_cache_operation - Begin a cache operation for a read
>   * @rreq: The read request
> @@ -103,36 +92,13 @@ static int v9fs_begin_cache_operation(struct netfs_io_request *rreq)
>  #endif
>  }
>  
> -static const struct netfs_request_ops v9fs_req_ops = {
> +const struct netfs_request_ops v9fs_req_ops = {
>  	.init_request		= v9fs_init_request,
> -	.is_cache_enabled	= v9fs_is_cache_enabled,
>  	.begin_cache_operation	= v9fs_begin_cache_operation,
>  	.issue_read		= v9fs_issue_read,
>  	.cleanup		= v9fs_req_cleanup,
>  };
>  
> -/**
> - * v9fs_vfs_readpage - read an entire page in from 9P
> - * @file: file being read
> - * @page: structure to page
> - *
> - */
> -static int v9fs_vfs_readpage(struct file *file, struct page *page)
> -{
> -	struct folio *folio = page_folio(page);
> -
> -	return netfs_readpage(file, folio, &v9fs_req_ops, NULL);
> -}
> -
> -/**
> - * v9fs_vfs_readahead - read a set of pages from 9P
> - * @ractl: The readahead parameters
> - */
> -static void v9fs_vfs_readahead(struct readahead_control *ractl)
> -{
> -	netfs_readahead(ractl, &v9fs_req_ops, NULL);
> -}
> -
>  /**
>   * v9fs_release_page - release the private state associated with a page
>   * @page: The page to be released
> @@ -326,8 +292,7 @@ static int v9fs_write_begin(struct file *filp, struct address_space *mapping,
>  	 * file.  We need to do this before we get a lock on the page in case
>  	 * there's more than one writer competing for the same cache block.
>  	 */
> -	retval = netfs_write_begin(filp, mapping, pos, len, flags, &folio, fsdata,
> -				   &v9fs_req_ops, NULL);
> +	retval = netfs_write_begin(filp, mapping, pos, len, flags, &folio, fsdata);
>  	if (retval < 0)
>  		return retval;
>  
> @@ -388,8 +353,8 @@ static int v9fs_set_page_dirty(struct page *page)
>  #endif
>  
>  const struct address_space_operations v9fs_addr_operations = {
> -	.readpage = v9fs_vfs_readpage,
> -	.readahead = v9fs_vfs_readahead,
> +	.readpage = netfs_readpage,
> +	.readahead = netfs_readahead,
>  	.set_page_dirty = v9fs_set_page_dirty,
>  	.writepage = v9fs_vfs_writepage,
>  	.write_begin = v9fs_write_begin,
> diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
> index 2a10242c79c7..a7dc6781a622 100644
> --- a/fs/9p/vfs_inode.c
> +++ b/fs/9p/vfs_inode.c
> @@ -231,9 +231,6 @@ struct inode *v9fs_alloc_inode(struct super_block *sb)
>  	v9inode = kmem_cache_alloc(v9fs_inode_cache, GFP_KERNEL);
>  	if (!v9inode)
>  		return NULL;
> -#ifdef CONFIG_9P_FSCACHE
> -	v9inode->fscache = NULL;
> -#endif
>  	v9inode->writeback_fid = NULL;
>  	v9inode->cache_validity = 0;
>  	mutex_init(&v9inode->v_mutex);
> @@ -250,6 +247,14 @@ void v9fs_free_inode(struct inode *inode)
>  	kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
>  }
>  
> +/*
> + * Set parameters for the netfs library
> + */
> +static void v9fs_set_netfs_context(struct inode *inode)
> +{
> +	netfs_i_context_init(inode, &v9fs_req_ops);
> +}
> +
>  int v9fs_init_inode(struct v9fs_session_info *v9ses,
>  		    struct inode *inode, umode_t mode, dev_t rdev)
>  {
> @@ -338,6 +343,8 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
>  		err = -EINVAL;
>  		goto error;
>  	}
> +
> +	v9fs_set_netfs_context(inode);
>  error:
>  	return err;
>  
> diff --git a/fs/afs/dynroot.c b/fs/afs/dynroot.c
> index db832cc931c8..f120bcb8bf73 100644
> --- a/fs/afs/dynroot.c
> +++ b/fs/afs/dynroot.c
> @@ -76,6 +76,7 @@ struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root)
>  	/* there shouldn't be an existing inode */
>  	BUG_ON(!(inode->i_state & I_NEW));
>  
> +	netfs_i_context_init(inode, NULL);
>  	inode->i_size		= 0;
>  	inode->i_mode		= S_IFDIR | S_IRUGO | S_IXUGO;
>  	if (root) {
> diff --git a/fs/afs/file.c b/fs/afs/file.c
> index 6469d7f98ef5..2b68b2070248 100644
> --- a/fs/afs/file.c
> +++ b/fs/afs/file.c
> @@ -19,13 +19,11 @@
>  #include "internal.h"
>  
>  static int afs_file_mmap(struct file *file, struct vm_area_struct *vma);
> -static int afs_readpage(struct file *file, struct page *page);
>  static int afs_symlink_readpage(struct file *file, struct page *page);
>  static void afs_invalidatepage(struct page *page, unsigned int offset,
>  			       unsigned int length);
>  static int afs_releasepage(struct page *page, gfp_t gfp_flags);
>  
> -static void afs_readahead(struct readahead_control *ractl);
>  static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter);
>  static void afs_vm_open(struct vm_area_struct *area);
>  static void afs_vm_close(struct vm_area_struct *area);
> @@ -52,8 +50,8 @@ const struct inode_operations afs_file_inode_operations = {
>  };
>  
>  const struct address_space_operations afs_file_aops = {
> -	.readpage	= afs_readpage,
> -	.readahead	= afs_readahead,
> +	.readpage	= netfs_readpage,
> +	.readahead	= netfs_readahead,
>  	.set_page_dirty	= afs_set_page_dirty,
>  	.launder_page	= afs_launder_page,
>  	.releasepage	= afs_releasepage,
> @@ -365,13 +363,6 @@ static int afs_init_request(struct netfs_io_request *rreq, struct file *file)
>  	return 0;
>  }
>  
> -static bool afs_is_cache_enabled(struct inode *inode)
> -{
> -	struct fscache_cookie *cookie = afs_vnode_cache(AFS_FS_I(inode));
> -
> -	return fscache_cookie_enabled(cookie) && cookie->cache_priv;
> -}
> -
>  static int afs_begin_cache_operation(struct netfs_io_request *rreq)
>  {
>  #ifdef CONFIG_AFS_FSCACHE
> @@ -399,25 +390,12 @@ static void afs_priv_cleanup(struct address_space *mapping, void *netfs_priv)
>  
>  const struct netfs_request_ops afs_req_ops = {
>  	.init_request		= afs_init_request,
> -	.is_cache_enabled	= afs_is_cache_enabled,
>  	.begin_cache_operation	= afs_begin_cache_operation,
>  	.check_write_begin	= afs_check_write_begin,
>  	.issue_read		= afs_issue_read,
>  	.cleanup		= afs_priv_cleanup,
>  };
>  
> -static int afs_readpage(struct file *file, struct page *page)
> -{
> -	struct folio *folio = page_folio(page);
> -
> -	return netfs_readpage(file, folio, &afs_req_ops, NULL);
> -}
> -
> -static void afs_readahead(struct readahead_control *ractl)
> -{
> -	netfs_readahead(ractl, &afs_req_ops, NULL);
> -}
> -
>  int afs_write_inode(struct inode *inode, struct writeback_control *wbc)
>  {
>  	fscache_unpin_writeback(wbc, afs_vnode_cache(AFS_FS_I(inode)));
> diff --git a/fs/afs/inode.c b/fs/afs/inode.c
> index 5964f8aee090..5b5e40197655 100644
> --- a/fs/afs/inode.c
> +++ b/fs/afs/inode.c
> @@ -53,6 +53,14 @@ static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *paren
>  		dump_stack();
>  }
>  
> +/*
> + * Set parameters for the netfs library
> + */
> +static void afs_set_netfs_context(struct afs_vnode *vnode)
> +{
> +	netfs_i_context_init(&vnode->vfs_inode, &afs_req_ops);
> +}
> +
>  /*
>   * Initialise an inode from the vnode status.
>   */
> @@ -128,6 +136,7 @@ static int afs_inode_init_from_status(struct afs_operation *op,
>  	}
>  
>  	afs_set_i_size(vnode, status->size);
> +	afs_set_netfs_context(vnode);
>  
>  	vnode->invalid_before	= status->data_version;
>  	inode_set_iversion_raw(&vnode->vfs_inode, status->data_version);
> @@ -420,7 +429,7 @@ static void afs_get_inode_cache(struct afs_vnode *vnode)
>  	struct afs_vnode_cache_aux aux;
>  
>  	if (vnode->status.type != AFS_FTYPE_FILE) {
> -		vnode->cache = NULL;
> +		vnode->netfs_ctx.cache = NULL;
>  		return;
>  	}
>  
> @@ -430,12 +439,14 @@ static void afs_get_inode_cache(struct afs_vnode *vnode)
>  	key.vnode_id_ext[1]	= htonl(vnode->fid.vnode_hi);
>  	afs_set_cache_aux(vnode, &aux);
>  
> -	vnode->cache = fscache_acquire_cookie(
> -		vnode->volume->cache,
> -		vnode->status.type == AFS_FTYPE_FILE ? 0 : FSCACHE_ADV_SINGLE_CHUNK,
> -		&key, sizeof(key),
> -		&aux, sizeof(aux),
> -		vnode->status.size);
> +	afs_vnode_set_cache(vnode,
> +			    fscache_acquire_cookie(
> +				    vnode->volume->cache,
> +				    vnode->status.type == AFS_FTYPE_FILE ?
> +				    0 : FSCACHE_ADV_SINGLE_CHUNK,
> +				    &key, sizeof(key),
> +				    &aux, sizeof(aux),
> +				    vnode->status.size));
>  #endif
>  }
>  
> @@ -528,6 +539,7 @@ struct inode *afs_root_iget(struct super_block *sb, struct key *key)
>  
>  	vnode = AFS_FS_I(inode);
>  	vnode->cb_v_break = as->volume->cb_v_break,
> +	afs_set_netfs_context(vnode);
>  
>  	op = afs_alloc_operation(key, as->volume);
>  	if (IS_ERR(op)) {
> @@ -786,11 +798,8 @@ void afs_evict_inode(struct inode *inode)
>  		afs_put_wb_key(wbk);
>  	}
>  
> -#ifdef CONFIG_AFS_FSCACHE
> -	fscache_relinquish_cookie(vnode->cache,
> +	fscache_relinquish_cookie(afs_vnode_cache(vnode),
>  				  test_bit(AFS_VNODE_DELETED, &vnode->flags));
> -	vnode->cache = NULL;
> -#endif
>  
>  	afs_prune_wb_keys(vnode);
>  	afs_put_permits(rcu_access_pointer(vnode->permit_cache));
> diff --git a/fs/afs/internal.h b/fs/afs/internal.h
> index c56a0e1719ae..75ca3026457e 100644
> --- a/fs/afs/internal.h
> +++ b/fs/afs/internal.h
> @@ -619,15 +619,16 @@ enum afs_lock_state {
>   * leak from one inode to another.
>   */
>  struct afs_vnode {
> -	struct inode		vfs_inode;	/* the VFS's inode record */
> +	struct {
> +		/* These must be contiguous */
> +		struct inode	vfs_inode;	/* the VFS's inode record */
> +		struct netfs_i_context netfs_ctx; /* Netfslib context */
> +	};
>  
>  	struct afs_volume	*volume;	/* volume on which vnode resides */
>  	struct afs_fid		fid;		/* the file identifier for this inode */
>  	struct afs_file_status	status;		/* AFS status info for this file */
>  	afs_dataversion_t	invalid_before;	/* Child dentries are invalid before this */
> -#ifdef CONFIG_AFS_FSCACHE
> -	struct fscache_cookie	*cache;		/* caching cookie */
> -#endif
>  	struct afs_permits __rcu *permit_cache;	/* cache of permits so far obtained */
>  	struct mutex		io_lock;	/* Lock for serialising I/O on this mutex */
>  	struct rw_semaphore	validate_lock;	/* lock for validating this vnode */
> @@ -674,12 +675,20 @@ struct afs_vnode {
>  static inline struct fscache_cookie *afs_vnode_cache(struct afs_vnode *vnode)
>  {
>  #ifdef CONFIG_AFS_FSCACHE
> -	return vnode->cache;
> +	return netfs_i_cookie(&vnode->vfs_inode);
>  #else
>  	return NULL;
>  #endif
>  }
>  
> +static inline void afs_vnode_set_cache(struct afs_vnode *vnode,
> +				       struct fscache_cookie *cookie)
> +{
> +#ifdef CONFIG_AFS_FSCACHE
> +	vnode->netfs_ctx.cache = cookie;
> +#endif
> +}
> +
>  /*
>   * cached security record for one user's attempt to access a vnode
>   */
> diff --git a/fs/afs/super.c b/fs/afs/super.c
> index 5ec9fd97eccc..e66c6f54ac8e 100644
> --- a/fs/afs/super.c
> +++ b/fs/afs/super.c
> @@ -688,13 +688,11 @@ static struct inode *afs_alloc_inode(struct super_block *sb)
>  	/* Reset anything that shouldn't leak from one inode to the next. */
>  	memset(&vnode->fid, 0, sizeof(vnode->fid));
>  	memset(&vnode->status, 0, sizeof(vnode->status));
> +	afs_vnode_set_cache(vnode, NULL);
>  
>  	vnode->volume		= NULL;
>  	vnode->lock_key		= NULL;
>  	vnode->permit_cache	= NULL;
> -#ifdef CONFIG_AFS_FSCACHE
> -	vnode->cache		= NULL;
> -#endif
>  
>  	vnode->flags		= 1 << AFS_VNODE_UNSET;
>  	vnode->lock_state	= AFS_VNODE_LOCK_NONE;
> diff --git a/fs/afs/write.c b/fs/afs/write.c
> index 5e9157d0da29..e4b47f67a408 100644
> --- a/fs/afs/write.c
> +++ b/fs/afs/write.c
> @@ -59,8 +59,7 @@ int afs_write_begin(struct file *file, struct address_space *mapping,
>  	 * file.  We need to do this before we get a lock on the page in case
>  	 * there's more than one writer competing for the same cache block.
>  	 */
> -	ret = netfs_write_begin(file, mapping, pos, len, flags, &folio, fsdata,
> -				&afs_req_ops, NULL);
> +	ret = netfs_write_begin(file, mapping, pos, len, flags, &folio, fsdata);
>  	if (ret < 0)
>  		return ret;
>  
> diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
> index 6d056db41f50..97ae65c7bed1 100644
> --- a/fs/ceph/addr.c
> +++ b/fs/ceph/addr.c
> @@ -403,7 +403,7 @@ static void ceph_readahead_cleanup(struct address_space *mapping, void *priv)
>  		ceph_put_cap_refs(ci, got);
>  }
>  
> -static const struct netfs_request_ops ceph_netfs_read_ops = {
> +const struct netfs_request_ops ceph_netfs_ops = {
>  	.init_request		= ceph_init_request,
>  	.begin_cache_operation	= ceph_begin_cache_operation,
>  	.issue_read		= ceph_netfs_issue_read,
> @@ -413,28 +413,6 @@ static const struct netfs_request_ops ceph_netfs_read_ops = {
>  	.cleanup		= ceph_readahead_cleanup,
>  };
>  
> -/* read a single page, without unlocking it. */
> -static int ceph_readpage(struct file *file, struct page *subpage)
> -{
> -	struct folio *folio = page_folio(subpage);
> -	struct inode *inode = file_inode(file);
> -	struct ceph_inode_info *ci = ceph_inode(inode);
> -	struct ceph_vino vino = ceph_vino(inode);
> -	size_t len = folio_size(folio);
> -	u64 off = folio_file_pos(folio);
> -
> -	dout("readpage ino %llx.%llx file %p off %llu len %zu folio %p index %lu\n inline %d",
> -	     vino.ino, vino.snap, file, off, len, folio, folio_index(folio),
> -	     ci->i_inline_version != CEPH_INLINE_NONE);
> -
> -	return netfs_readpage(file, folio, &ceph_netfs_read_ops, NULL);
> -}
> -
> -static void ceph_readahead(struct readahead_control *ractl)
> -{
> -	netfs_readahead(ractl, &ceph_netfs_read_ops, NULL);
> -}
> -
>  #ifdef CONFIG_CEPH_FSCACHE
>  static void ceph_set_page_fscache(struct page *page)
>  {
> @@ -1333,8 +1311,7 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping,
>  	struct folio *folio = NULL;
>  	int r;
>  
> -	r = netfs_write_begin(file, inode->i_mapping, pos, len, 0, &folio, NULL,
> -			      &ceph_netfs_read_ops, NULL);
> +	r = netfs_write_begin(file, inode->i_mapping, pos, len, 0, &folio, NULL);
>  	if (r == 0)
>  		folio_wait_fscache(folio);
>  	if (r < 0) {
> @@ -1388,8 +1365,8 @@ static int ceph_write_end(struct file *file, struct address_space *mapping,
>  }
>  
>  const struct address_space_operations ceph_aops = {
> -	.readpage = ceph_readpage,
> -	.readahead = ceph_readahead,
> +	.readpage = netfs_readpage,
> +	.readahead = netfs_readahead,
>  	.writepage = ceph_writepage,
>  	.writepages = ceph_writepages_start,
>  	.write_begin = ceph_write_begin,
> diff --git a/fs/ceph/cache.c b/fs/ceph/cache.c
> index 7d22850623ef..ddea99922073 100644
> --- a/fs/ceph/cache.c
> +++ b/fs/ceph/cache.c
> @@ -29,26 +29,25 @@ void ceph_fscache_register_inode_cookie(struct inode *inode)
>  	if (!(inode->i_state & I_NEW))
>  		return;
>  
> -	WARN_ON_ONCE(ci->fscache);
> +	WARN_ON_ONCE(ci->netfs_ctx.cache);
>  
> -	ci->fscache = fscache_acquire_cookie(fsc->fscache, 0,
> -					     &ci->i_vino, sizeof(ci->i_vino),
> -					     &ci->i_version, sizeof(ci->i_version),
> -					     i_size_read(inode));
> +	ci->netfs_ctx.cache =
> +		fscache_acquire_cookie(fsc->fscache, 0,
> +				       &ci->i_vino, sizeof(ci->i_vino),
> +				       &ci->i_version, sizeof(ci->i_version),
> +				       i_size_read(inode));
>  }
>  
> -void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info* ci)
> +void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info *ci)
>  {
> -	struct fscache_cookie *cookie = ci->fscache;
> -
> -	fscache_relinquish_cookie(cookie, false);
> +	fscache_relinquish_cookie(ceph_fscache_cookie(ci), false);
>  }
>  
>  void ceph_fscache_use_cookie(struct inode *inode, bool will_modify)
>  {
>  	struct ceph_inode_info *ci = ceph_inode(inode);
>  
> -	fscache_use_cookie(ci->fscache, will_modify);
> +	fscache_use_cookie(ceph_fscache_cookie(ci), will_modify);
>  }
>  
>  void ceph_fscache_unuse_cookie(struct inode *inode, bool update)
> @@ -58,9 +57,10 @@ void ceph_fscache_unuse_cookie(struct inode *inode, bool update)
>  	if (update) {
>  		loff_t i_size = i_size_read(inode);
>  
> -		fscache_unuse_cookie(ci->fscache, &ci->i_version, &i_size);
> +		fscache_unuse_cookie(ceph_fscache_cookie(ci),
> +				     &ci->i_version, &i_size);
>  	} else {
> -		fscache_unuse_cookie(ci->fscache, NULL, NULL);
> +		fscache_unuse_cookie(ceph_fscache_cookie(ci), NULL, NULL);
>  	}
>  }
>  
> @@ -69,14 +69,14 @@ void ceph_fscache_update(struct inode *inode)
>  	struct ceph_inode_info *ci = ceph_inode(inode);
>  	loff_t i_size = i_size_read(inode);
>  
> -	fscache_update_cookie(ci->fscache, &ci->i_version, &i_size);
> +	fscache_update_cookie(ceph_fscache_cookie(ci), &ci->i_version, &i_size);
>  }
>  
>  void ceph_fscache_invalidate(struct inode *inode, bool dio_write)
>  {
>  	struct ceph_inode_info *ci = ceph_inode(inode);
>  
> -	fscache_invalidate(ceph_inode(inode)->fscache,
> +	fscache_invalidate(ceph_fscache_cookie(ci),
>  			   &ci->i_version, i_size_read(inode),
>  			   dio_write ? FSCACHE_INVAL_DIO_WRITE : 0);
>  }
> diff --git a/fs/ceph/cache.h b/fs/ceph/cache.h
> index b8b3b5cb6438..c20e43cade94 100644
> --- a/fs/ceph/cache.h
> +++ b/fs/ceph/cache.h
> @@ -26,14 +26,9 @@ void ceph_fscache_unuse_cookie(struct inode *inode, bool update);
>  void ceph_fscache_update(struct inode *inode);
>  void ceph_fscache_invalidate(struct inode *inode, bool dio_write);
>  
> -static inline void ceph_fscache_inode_init(struct ceph_inode_info *ci)
> -{
> -	ci->fscache = NULL;
> -}
> -
>  static inline struct fscache_cookie *ceph_fscache_cookie(struct ceph_inode_info *ci)
>  {
> -	return ci->fscache;
> +	return netfs_i_cookie(&ci->vfs_inode);
>  }
>  
>  static inline void ceph_fscache_resize(struct inode *inode, loff_t to)
> @@ -91,10 +86,6 @@ static inline void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc)
>  {
>  }
>  
> -static inline void ceph_fscache_inode_init(struct ceph_inode_info *ci)
> -{
> -}
> -
>  static inline void ceph_fscache_register_inode_cookie(struct inode *inode)
>  {
>  }
> diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
> index 7b1e93c8a0d2..6a176d9d394a 100644
> --- a/fs/ceph/inode.c
> +++ b/fs/ceph/inode.c
> @@ -453,6 +453,9 @@ struct inode *ceph_alloc_inode(struct super_block *sb)
>  
>  	dout("alloc_inode %p\n", &ci->vfs_inode);
>  
> +	/* Set parameters for the netfs library */
> +	netfs_i_context_init(&ci->vfs_inode, &ceph_netfs_ops);
> +
>  	spin_lock_init(&ci->i_ceph_lock);
>  
>  	ci->i_version = 0;
> @@ -538,9 +541,6 @@ struct inode *ceph_alloc_inode(struct super_block *sb)
>  	INIT_WORK(&ci->i_work, ceph_inode_work);
>  	ci->i_work_mask = 0;
>  	memset(&ci->i_btime, '\0', sizeof(ci->i_btime));
> -
> -	ceph_fscache_inode_init(ci);
> -
>  	return &ci->vfs_inode;
>  }
>  
> diff --git a/fs/ceph/super.h b/fs/ceph/super.h
> index 0b4b519682f1..e1c65aa8d3b6 100644
> --- a/fs/ceph/super.h
> +++ b/fs/ceph/super.h
> @@ -17,13 +17,11 @@
>  #include <linux/posix_acl.h>
>  #include <linux/refcount.h>
>  #include <linux/security.h>
> +#include <linux/netfs.h>
> +#include <linux/fscache.h>
>  
>  #include <linux/ceph/libceph.h>
>  
> -#ifdef CONFIG_CEPH_FSCACHE
> -#include <linux/fscache.h>
> -#endif
> -
>  /* large granularity for statfs utilization stats to facilitate
>   * large volume sizes on 32-bit machines. */
>  #define CEPH_BLOCK_SHIFT   22  /* 4 MB */
> @@ -317,6 +315,11 @@ struct ceph_inode_xattrs_info {
>   * Ceph inode.
>   */
>  struct ceph_inode_info {
> +	struct {
> +		/* These must be contiguous */
> +		struct inode vfs_inode;
> +		struct netfs_i_context netfs_ctx; /* Netfslib context */
> +	};
>  	struct ceph_vino i_vino;   /* ceph ino + snap */
>  
>  	spinlock_t i_ceph_lock;
> @@ -427,11 +430,6 @@ struct ceph_inode_info {
>  
>  	struct work_struct i_work;
>  	unsigned long  i_work_mask;
> -
> -#ifdef CONFIG_CEPH_FSCACHE
> -	struct fscache_cookie *fscache;
> -#endif
> -	struct inode vfs_inode; /* at end */
>  };
>  
>  static inline struct ceph_inode_info *
> @@ -1215,6 +1213,7 @@ extern void __ceph_touch_fmode(struct ceph_inode_info *ci,
>  
>  /* addr.c */
>  extern const struct address_space_operations ceph_aops;
> +extern const struct netfs_request_ops ceph_netfs_ops;
>  extern int ceph_mmap(struct file *file, struct vm_area_struct *vma);
>  extern int ceph_uninline_data(struct file *file);
>  extern int ceph_pool_perm_check(struct inode *inode, int need);
> diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
> index 48b343d03430..0a4085ced40f 100644
> --- a/fs/cifs/cifsglob.h
> +++ b/fs/cifs/cifsglob.h
> @@ -16,6 +16,7 @@
>  #include <linux/mempool.h>
>  #include <linux/workqueue.h>
>  #include <linux/utsname.h>
> +#include <linux/netfs.h>
>  #include "cifs_fs_sb.h"
>  #include "cifsacl.h"
>  #include <crypto/internal/hash.h>
> @@ -1402,6 +1403,11 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
>   */
>  
>  struct cifsInodeInfo {
> +	struct {
> +		/* These must be contiguous */
> +		struct inode	vfs_inode;	/* the VFS's inode record */
> +		struct netfs_i_context netfs_ctx; /* Netfslib context */
> +	};
>  	bool can_cache_brlcks;
>  	struct list_head llist;	/* locks helb by this inode */
>  	/*
> @@ -1432,10 +1438,6 @@ struct cifsInodeInfo {
>  	u64  uniqueid;			/* server inode number */
>  	u64  createtime;		/* creation time on server */
>  	__u8 lease_key[SMB2_LEASE_KEY_SIZE];	/* lease key for this inode */
> -#ifdef CONFIG_CIFS_FSCACHE
> -	struct fscache_cookie *fscache;
> -#endif
> -	struct inode vfs_inode;
>  	struct list_head deferred_closes; /* list of deferred closes */
>  	spinlock_t deferred_lock; /* protection on deferred list */
>  	bool lease_granted; /* Flag to indicate whether lease or oplock is granted. */
> diff --git a/fs/cifs/fscache.c b/fs/cifs/fscache.c
> index b47c2011ce5b..a638b29e9062 100644
> --- a/fs/cifs/fscache.c
> +++ b/fs/cifs/fscache.c
> @@ -103,7 +103,7 @@ void cifs_fscache_get_inode_cookie(struct inode *inode)
>  
>  	cifs_fscache_fill_coherency(&cifsi->vfs_inode, &cd);
>  
> -	cifsi->fscache =
> +	cifsi->netfs_ctx.cache =
>  		fscache_acquire_cookie(tcon->fscache, 0,
>  				       &cifsi->uniqueid, sizeof(cifsi->uniqueid),
>  				       &cd, sizeof(cd),
> @@ -126,11 +126,12 @@ void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool update)
>  void cifs_fscache_release_inode_cookie(struct inode *inode)
>  {
>  	struct cifsInodeInfo *cifsi = CIFS_I(inode);
> +	struct fscache_cookie *cookie = cifs_inode_cookie(inode);
>  
> -	if (cifsi->fscache) {
> -		cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cifsi->fscache);
> -		fscache_relinquish_cookie(cifsi->fscache, false);
> -		cifsi->fscache = NULL;
> +	if (cookie) {
> +		cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cookie);
> +		fscache_relinquish_cookie(cookie, false);
> +		cifsi->netfs_ctx.cache = NULL;
>  	}
>  }
>  
> diff --git a/fs/cifs/fscache.h b/fs/cifs/fscache.h
> index 55129908e2c1..52355c0912ae 100644
> --- a/fs/cifs/fscache.h
> +++ b/fs/cifs/fscache.h
> @@ -61,7 +61,7 @@ void cifs_fscache_fill_coherency(struct inode *inode,
>  
>  static inline struct fscache_cookie *cifs_inode_cookie(struct inode *inode)
>  {
> -	return CIFS_I(inode)->fscache;
> +	return netfs_i_cookie(inode);
>  }
>  
>  static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags)
> diff --git a/fs/netfs/internal.h b/fs/netfs/internal.h
> index 89837e904fa7..5f9719409f21 100644
> --- a/fs/netfs/internal.h
> +++ b/fs/netfs/internal.h
> @@ -6,6 +6,7 @@
>   */
>  
>  #include <linux/netfs.h>
> +#include <linux/fscache.h>
>  #include <trace/events/netfs.h>
>  
>  #ifdef pr_fmt
> @@ -19,8 +20,6 @@
>   */
>  struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,
>  					     struct file *file,
> -					     const struct netfs_request_ops *ops,
> -					     void *netfs_priv,
>  					     loff_t start, size_t len,
>  					     enum netfs_io_origin origin);
>  void netfs_get_request(struct netfs_io_request *rreq, enum netfs_rreq_ref_trace what);
> @@ -81,6 +80,20 @@ static inline void netfs_stat_d(atomic_t *stat)
>  #define netfs_stat_d(x) do {} while(0)
>  #endif
>  
> +/*
> + * Miscellaneous functions.
> + */
> +static inline bool netfs_is_cache_enabled(struct netfs_i_context *ctx)
> +{
> +#if IS_ENABLED(CONFIG_FSCACHE)
> +	struct fscache_cookie *cookie = ctx->cache;
> +
> +	return fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie);
> +#else
> +	return false;
> +#endif
> +}
> +
>  /*****************************************************************************/
>  /*
>   * debug tracing
> diff --git a/fs/netfs/objects.c b/fs/netfs/objects.c
> index ae18827e156b..657b19e60118 100644
> --- a/fs/netfs/objects.c
> +++ b/fs/netfs/objects.c
> @@ -13,12 +13,12 @@
>   */
>  struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,
>  					     struct file *file,
> -					     const struct netfs_request_ops *ops,
> -					     void *netfs_priv,
>  					     loff_t start, size_t len,
>  					     enum netfs_io_origin origin)
>  {
>  	static atomic_t debug_ids;
> +	struct inode *inode = file ? file_inode(file) : mapping->host;
> +	struct netfs_i_context *ctx = netfs_i_context(inode);
>  	struct netfs_io_request *rreq;
>  	int ret;
>  
> @@ -29,11 +29,10 @@ struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,
>  	rreq->start	= start;
>  	rreq->len	= len;
>  	rreq->origin	= origin;
> -	rreq->netfs_ops	= ops;
> -	rreq->netfs_priv = netfs_priv;
> +	rreq->netfs_ops	= ctx->ops;
>  	rreq->mapping	= mapping;
> -	rreq->inode	= file_inode(file);
> -	rreq->i_size	= i_size_read(rreq->inode);
> +	rreq->inode	= inode;
> +	rreq->i_size	= i_size_read(inode);
>  	rreq->debug_id	= atomic_inc_return(&debug_ids);
>  	INIT_LIST_HEAD(&rreq->subrequests);
>  	INIT_WORK(&rreq->work, netfs_rreq_work);
> @@ -76,6 +75,7 @@ static void netfs_free_request(struct work_struct *work)
>  {
>  	struct netfs_io_request *rreq =
>  		container_of(work, struct netfs_io_request, work);
> +
>  	netfs_clear_subrequests(rreq, false);
>  	if (rreq->netfs_priv)
>  		rreq->netfs_ops->cleanup(rreq->mapping, rreq->netfs_priv);
> diff --git a/fs/netfs/read_helper.c b/fs/netfs/read_helper.c
> index b5176f4320f4..73be06c409bb 100644
> --- a/fs/netfs/read_helper.c
> +++ b/fs/netfs/read_helper.c
> @@ -14,7 +14,6 @@
>  #include <linux/uio.h>
>  #include <linux/sched/mm.h>
>  #include <linux/task_io_accounting_ops.h>
> -#include <linux/netfs.h>
>  #include "internal.h"
>  #define CREATE_TRACE_POINTS
>  #include <trace/events/netfs.h>
> @@ -735,8 +734,6 @@ static void netfs_rreq_expand(struct netfs_io_request *rreq,
>  /**
>   * netfs_readahead - Helper to manage a read request
>   * @ractl: The description of the readahead request
> - * @ops: The network filesystem's operations for the helper to use
> - * @netfs_priv: Private netfs data to be retained in the request
>   *
>   * Fulfil a readahead request by drawing data from the cache if possible, or
>   * the netfs if not.  Space beyond the EOF is zero-filled.  Multiple I/O
> @@ -744,35 +741,32 @@ static void netfs_rreq_expand(struct netfs_io_request *rreq,
>   * readahead window can be expanded in either direction to a more convenient
>   * alighment for RPC efficiency or to make storage in the cache feasible.
>   *
> - * The calling netfs must provide a table of operations, only one of which,
> - * issue_op, is mandatory.  It may also be passed a private token, which will
> - * be retained in rreq->netfs_priv and will be cleaned up by ops->cleanup().
> + * The calling netfs must initialise a netfs context contiguous to the vfs
> + * inode before calling this.
>   *
>   * This is usable whether or not caching is enabled.
>   */
> -void netfs_readahead(struct readahead_control *ractl,
> -		     const struct netfs_request_ops *ops,
> -		     void *netfs_priv)
> +void netfs_readahead(struct readahead_control *ractl)
>  {
>  	struct netfs_io_request *rreq;
> +	struct netfs_i_context *ctx = netfs_i_context(ractl->mapping->host);
>  	unsigned int debug_index = 0;
>  	int ret;
>  
>  	_enter("%lx,%x", readahead_index(ractl), readahead_count(ractl));
>  
>  	if (readahead_count(ractl) == 0)
> -		goto cleanup;
> +		return;
>  
>  	rreq = netfs_alloc_request(ractl->mapping, ractl->file,
> -				   ops, netfs_priv,
>  				   readahead_pos(ractl),
>  				   readahead_length(ractl),
>  				   NETFS_READAHEAD);
>  	if (IS_ERR(rreq))
> -		goto cleanup;
> +		return;
>  
> -	if (ops->begin_cache_operation) {
> -		ret = ops->begin_cache_operation(rreq);
> +	if (ctx->ops->begin_cache_operation) {
> +		ret = ctx->ops->begin_cache_operation(rreq);
>  		if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
>  			goto cleanup_free;
>  	}
> @@ -804,42 +798,35 @@ void netfs_readahead(struct readahead_control *ractl,
>  cleanup_free:
>  	netfs_put_request(rreq, false, netfs_rreq_trace_put_failed);
>  	return;
> -cleanup:
> -	if (netfs_priv)
> -		ops->cleanup(ractl->mapping, netfs_priv);
> -	return;
>  }
>  EXPORT_SYMBOL(netfs_readahead);
>  
>  /**
>   * netfs_readpage - Helper to manage a readpage request
>   * @file: The file to read from
> - * @folio: The folio to read
> - * @ops: The network filesystem's operations for the helper to use
> - * @netfs_priv: Private netfs data to be retained in the request
> + * @subpage: A subpage of the folio to read
>   *
>   * Fulfil a readpage request by drawing data from the cache if possible, or the
>   * netfs if not.  Space beyond the EOF is zero-filled.  Multiple I/O requests
>   * from different sources will get munged together.
>   *
> - * The calling netfs must provide a table of operations, only one of which,
> - * issue_op, is mandatory.  It may also be passed a private token, which will
> - * be retained in rreq->netfs_priv and will be cleaned up by ops->cleanup().
> + * The calling netfs must initialise a netfs context contiguous to the vfs
> + * inode before calling this.
>   *
>   * This is usable whether or not caching is enabled.
>   */
> -int netfs_readpage(struct file *file,
> -		   struct folio *folio,
> -		   const struct netfs_request_ops *ops,
> -		   void *netfs_priv)
> +int netfs_readpage(struct file *file, struct page *subpage)
>  {
> +	struct folio *folio = page_folio(subpage);
> +	struct address_space *mapping = folio->mapping;
>  	struct netfs_io_request *rreq;
> +	struct netfs_i_context *ctx = netfs_i_context(mapping->host);
>  	unsigned int debug_index = 0;
>  	int ret;
>  
>  	_enter("%lx", folio_index(folio));
>  
> -	rreq = netfs_alloc_request(folio->mapping, file, ops, netfs_priv,
> +	rreq = netfs_alloc_request(mapping, file,
>  				   folio_file_pos(folio), folio_size(folio),
>  				   NETFS_READPAGE);
>  	if (IS_ERR(rreq)) {
> @@ -847,8 +834,8 @@ int netfs_readpage(struct file *file,
>  		goto alloc_error;
>  	}
>  
> -	if (ops->begin_cache_operation) {
> -		ret = ops->begin_cache_operation(rreq);
> +	if (ctx->ops->begin_cache_operation) {
> +		ret = ctx->ops->begin_cache_operation(rreq);
>  		if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS) {
>  			folio_unlock(folio);
>  			goto out;
> @@ -886,8 +873,6 @@ int netfs_readpage(struct file *file,
>  	netfs_put_request(rreq, false, netfs_rreq_trace_put_hold);
>  	return ret;
>  alloc_error:
> -	if (netfs_priv)
> -		ops->cleanup(folio_file_mapping(folio), netfs_priv);
>  	folio_unlock(folio);
>  	return ret;
>  }
> @@ -898,6 +883,7 @@ EXPORT_SYMBOL(netfs_readpage);
>   * @folio: The folio being prepared
>   * @pos: starting position for the write
>   * @len: length of write
> + * @always_fill: T if the folio should always be completely filled/cleared
>   *
>   * In some cases, write_begin doesn't need to read at all:
>   * - full folio write
> @@ -907,17 +893,27 @@ EXPORT_SYMBOL(netfs_readpage);
>   * If any of these criteria are met, then zero out the unwritten parts
>   * of the folio and return true. Otherwise, return false.
>   */
> -static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len)
> +static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len,
> +				 bool always_fill)
>  {
>  	struct inode *inode = folio_inode(folio);
>  	loff_t i_size = i_size_read(inode);
>  	size_t offset = offset_in_folio(folio, pos);
> +	size_t plen = folio_size(folio);
> +
> +	if (unlikely(always_fill)) {
> +		if (pos - offset + len <= i_size)
> +			return false; /* Page entirely before EOF */
> +		zero_user_segment(&folio->page, 0, plen);
> +		folio_mark_uptodate(folio);
> +		return true;
> +	}
>  
>  	/* Full folio write */
> -	if (offset == 0 && len >= folio_size(folio))
> +	if (offset == 0 && len >= plen)
>  		return true;
>  
> -	/* pos beyond last folio in the file */
> +	/* Page entirely beyond the end of the file */
>  	if (pos - offset >= i_size)
>  		goto zero_out;
>  
> @@ -927,7 +923,7 @@ static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len)
>  
>  	return false;
>  zero_out:
> -	zero_user_segments(&folio->page, 0, offset, offset + len, folio_size(folio));
> +	zero_user_segments(&folio->page, 0, offset, offset + len, len);
>  	return true;
>  }
>  
> @@ -940,8 +936,6 @@ static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len)
>   * @aop_flags: AOP_* flags
>   * @_folio: Where to put the resultant folio
>   * @_fsdata: Place for the netfs to store a cookie
> - * @ops: The network filesystem's operations for the helper to use
> - * @netfs_priv: Private netfs data to be retained in the request
>   *
>   * Pre-read data for a write-begin request by drawing data from the cache if
>   * possible, or the netfs if not.  Space beyond the EOF is zero-filled.
> @@ -960,17 +954,18 @@ static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len)
>   * should go ahead; unlock the folio and return -EAGAIN to cause the folio to
>   * be regot; or return an error.
>   *
> + * The calling netfs must initialise a netfs context contiguous to the vfs
> + * inode before calling this.
> + *
>   * This is usable whether or not caching is enabled.
>   */
>  int netfs_write_begin(struct file *file, struct address_space *mapping,
>  		      loff_t pos, unsigned int len, unsigned int aop_flags,
> -		      struct folio **_folio, void **_fsdata,
> -		      const struct netfs_request_ops *ops,
> -		      void *netfs_priv)
> +		      struct folio **_folio, void **_fsdata)
>  {
>  	struct netfs_io_request *rreq;
> +	struct netfs_i_context *ctx = netfs_i_context(file_inode(file ));
>  	struct folio *folio;
> -	struct inode *inode = file_inode(file);
>  	unsigned int debug_index = 0, fgp_flags;
>  	pgoff_t index = pos >> PAGE_SHIFT;
>  	int ret;
> @@ -986,9 +981,9 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
>  	if (!folio)
>  		return -ENOMEM;
>  
> -	if (ops->check_write_begin) {
> +	if (ctx->ops->check_write_begin) {
>  		/* Allow the netfs (eg. ceph) to flush conflicts. */
> -		ret = ops->check_write_begin(file, pos, len, folio, _fsdata);
> +		ret = ctx->ops->check_write_begin(file, pos, len, folio, _fsdata);
>  		if (ret < 0) {
>  			trace_netfs_failure(NULL, NULL, ret, netfs_fail_check_write_begin);
>  			if (ret == -EAGAIN)
> @@ -1004,13 +999,13 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
>  	 * within the cache granule containing the EOF, in which case we need
>  	 * to preload the granule.
>  	 */
> -	if (!ops->is_cache_enabled(inode) &&
> -	    netfs_skip_folio_read(folio, pos, len)) {
> +	if (!netfs_is_cache_enabled(ctx) &&
> +	    netfs_skip_folio_read(folio, pos, len, false)) {
>  		netfs_stat(&netfs_n_rh_write_zskip);
>  		goto have_folio_no_wait;
>  	}
>  
> -	rreq = netfs_alloc_request(mapping, file, ops, netfs_priv,
> +	rreq = netfs_alloc_request(mapping, file,
>  				   folio_file_pos(folio), folio_size(folio),
>  				   NETFS_READ_FOR_WRITE);
>  	if (IS_ERR(rreq)) {
> @@ -1019,10 +1014,9 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
>  	}
>  	rreq->no_unlock_folio	= folio_index(folio);
>  	__set_bit(NETFS_RREQ_NO_UNLOCK_FOLIO, &rreq->flags);
> -	netfs_priv = NULL;
>  
> -	if (ops->begin_cache_operation) {
> -		ret = ops->begin_cache_operation(rreq);
> +	if (ctx->ops->begin_cache_operation) {
> +		ret = ctx->ops->begin_cache_operation(rreq);
>  		if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
>  			goto error_put;
>  	}
> @@ -1076,8 +1070,6 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
>  	if (ret < 0)
>  		goto error;
>  have_folio_no_wait:
> -	if (netfs_priv)
> -		ops->cleanup(mapping, netfs_priv);
>  	*_folio = folio;
>  	_leave(" = 0");
>  	return 0;
> @@ -1087,8 +1079,6 @@ int netfs_write_begin(struct file *file, struct address_space *mapping,
>  error:
>  	folio_unlock(folio);
>  	folio_put(folio);
> -	if (netfs_priv)
> -		ops->cleanup(mapping, netfs_priv);
>  	_leave(" = %d", ret);
>  	return ret;
>  }
> diff --git a/fs/netfs/stats.c b/fs/netfs/stats.c
> index 9ae538c85378..5510a7a14a40 100644
> --- a/fs/netfs/stats.c
> +++ b/fs/netfs/stats.c
> @@ -7,7 +7,6 @@
>  
>  #include <linux/export.h>
>  #include <linux/seq_file.h>
> -#include <linux/netfs.h>
>  #include "internal.h"
>  
>  atomic_t netfs_n_rh_readahead;
> diff --git a/include/linux/netfs.h b/include/linux/netfs.h
> index 4b99e38f73d9..8458b30172a5 100644
> --- a/include/linux/netfs.h
> +++ b/include/linux/netfs.h
> @@ -118,6 +118,16 @@ enum netfs_io_source {
>  typedef void (*netfs_io_terminated_t)(void *priv, ssize_t transferred_or_error,
>  				      bool was_async);
>  
> +/*
> + * Per-inode description.  This must be directly after the inode struct.
> + */
> +struct netfs_i_context {
> +	const struct netfs_request_ops *ops;
> +#if IS_ENABLED(CONFIG_FSCACHE)
> +	struct fscache_cookie	*cache;
> +#endif
> +};
> +
>  /*
>   * Resources required to do operations on a cache.
>   */
> @@ -192,7 +202,6 @@ struct netfs_io_request {
>   * Operations the network filesystem can/must provide to the helpers.
>   */
>  struct netfs_request_ops {
> -	bool (*is_cache_enabled)(struct inode *inode);
>  	int (*init_request)(struct netfs_io_request *rreq, struct file *file);
>  	int (*begin_cache_operation)(struct netfs_io_request *rreq);
>  	void (*expand_readahead)(struct netfs_io_request *rreq);
> @@ -263,18 +272,11 @@ struct netfs_cache_ops {
>  };
>  
>  struct readahead_control;
> -extern void netfs_readahead(struct readahead_control *,
> -			    const struct netfs_request_ops *,
> -			    void *);
> -extern int netfs_readpage(struct file *,
> -			  struct folio *,
> -			  const struct netfs_request_ops *,
> -			  void *);
> +extern void netfs_readahead(struct readahead_control *);
> +extern int netfs_readpage(struct file *, struct page *);
>  extern int netfs_write_begin(struct file *, struct address_space *,
>  			     loff_t, unsigned int, unsigned int, struct folio **,
> -			     void **,
> -			     const struct netfs_request_ops *,
> -			     void *);
> +			     void **);
>  
>  extern void netfs_subreq_terminated(struct netfs_io_subrequest *, ssize_t, bool);
>  extern void netfs_get_subrequest(struct netfs_io_subrequest *subreq,
> @@ -283,4 +285,61 @@ extern void netfs_put_subrequest(struct netfs_io_subrequest *subreq,
>  				 bool was_async, enum netfs_sreq_ref_trace what);
>  extern void netfs_stats_show(struct seq_file *);
>  
> +/**
> + * netfs_i_context - Get the netfs inode context from the inode
> + * @inode: The inode to query
> + *
> + * Get the netfs lib inode context from the network filesystem's inode.  The
> + * context struct is expected to directly follow on from the VFS inode struct.
> + */
> +static inline struct netfs_i_context *netfs_i_context(struct inode *inode)
> +{
> +	return (struct netfs_i_context *)(inode + 1);
> +}
> +
> +/**
> + * netfs_inode - Get the netfs inode from the inode context
> + * @ctx: The context to query
> + *
> + * Get the netfs inode from the netfs library's inode context.  The VFS inode
> + * is expected to directly precede the context struct.
> + */
> +static inline struct inode *netfs_inode(struct netfs_i_context *ctx)
> +{
> +	return ((struct inode *)ctx) - 1;
> +}
> +
> +/**
> + * netfs_i_context_init - Initialise a netfs lib context
> + * @inode: The inode with which the context is associated
> + * @ops: The netfs's operations list
> + *
> + * Initialise the netfs library context struct.  This is expected to follow on
> + * directly from the VFS inode struct.
> + */
> +static inline void netfs_i_context_init(struct inode *inode,
> +					const struct netfs_request_ops *ops)
> +{
> +	struct netfs_i_context *ctx = netfs_i_context(inode);
> +
> +	memset(ctx, 0, sizeof(*ctx));
> +	ctx->ops = ops;
> +}
> +
> +/**
> + * netfs_i_cookie - Get the cache cookie from the inode
> + * @inode: The inode to query
> + *
> + * Get the caching cookie (if enabled) from the network filesystem's inode.
> + */
> +static inline struct fscache_cookie *netfs_i_cookie(struct inode *inode)
> +{
> +#if IS_ENABLED(CONFIG_FSCACHE)
> +	struct netfs_i_context *ctx = netfs_i_context(inode);
> +	return ctx->cache;
> +#else
> +	return NULL;
> +#endif
> +}
> +
>  #endif /* _LINUX_NETFS_H */
> 
> 


I still think a struct netfs_inode would be cleaner, but I'll concede
that this does mean less churn in the filesystems.

It's still a big patch though, and reverting (or backporting) it will be
ugly. It might be worth it to break this up into a patch-per-fs
conversion series.

Either way, this is probably the most reasonable way forward.

Acked-by: Jeff Layton <jlayton at kernel.org>



More information about the linux-afs mailing list