Merge branch 'fscache-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs

provided.  Firstly, a function to perform basic initialisation on a context and

set the operations table pointer::

	void netfs_inode_init(struct inode *inode,

	void netfs_inode_init(struct netfs_inode *ctx,

			      const struct netfs_request_ops *ops);

then a function to cast from the VFS inode structure to the netfs context::

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);

	struct fscache_cookie *netfs_i_cookie(struct netfs_inode *ctx);

Buffered Read Helpers

	void netfs_readahead(struct readahead_control *ractl);

	int netfs_read_folio(struct file *file,

			     struct folio *folio);

	int netfs_write_begin(struct file *file,

	int netfs_write_begin(struct netfs_inode *ctx,

			      struct file *file,

			      struct address_space *mapping,

			      loff_t pos,

			      unsigned int len,

through the suppplied table of operations.  Waits will be performed as

necessary before returning for helpers that are meant to be synchronous.

If an error occurs and netfs_priv is non-NULL, ops->cleanup() will be called to

deal with it.  If some parts of the request are in progress when an error

occurs, the request will get partially completed if sufficient data is read.

If an error occurs, the ->free_request() will be called to clean up the

netfs_io_request struct allocated.  If some parts of the request are in

progress when an error occurs, the request will get partially completed if

sufficient data is read.

Additionally, there is::

 * ``netfs_priv``

   The network filesystem's private data.  The value for this can be passed in

   to the helper functions or set during the request.  The ->cleanup() op will

   be called if this is non-NULL at the end.

   to the helper functions or set during the request.

 * ``start``

 * ``len``

	struct netfs_request_ops {

		void (*init_request)(struct netfs_io_request *rreq, struct file *file);

		void (*free_request)(struct netfs_io_request *rreq);

		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);

		int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,

					 struct folio *folio, void **_fsdata);

		void (*done)(struct netfs_io_request *rreq);

		void (*cleanup)(struct address_space *mapping, void *netfs_priv);

	};

The operations are as follows:

 * ``init_request()``

   [Optional] This is called to initialise the request structure.  It is given

   the file for reference and can modify the ->netfs_priv value.

   the file for reference.

 * ``free_request()``

   [Optional] This is called as the request is being deallocated so that the

   filesystem can clean up any state it has attached there.

 * ``begin_cache_operation()``

   [Optional] This is called after the folios in the request have all been

   unlocked (and marked uptodate if applicable).

 * ``cleanup``

   [Optional] This is called as the request is being deallocated so that the

   filesystem can clean up ->netfs_priv.

Read Helper Procedure

static inline struct fscache_cookie *v9fs_inode_cookie(struct v9fs_inode *v9inode)

{

#ifdef CONFIG_9P_FSCACHE

	return netfs_i_cookie(&v9inode->netfs.inode);

	return netfs_i_cookie(&v9inode->netfs);

#else

	return NULL;

#endif

}

/**

 * v9fs_req_cleanup - Cleanup request initialized by v9fs_init_request

 * @mapping: unused mapping of request to cleanup

 * @priv: private data to cleanup, a fid, guaranted non-null.

 * v9fs_free_request - Cleanup request initialized by v9fs_init_rreq

 * @rreq: The I/O request to clean up

 */

static void v9fs_req_cleanup(struct address_space *mapping, void *priv)

static void v9fs_free_request(struct netfs_io_request *rreq)

{

	struct p9_fid *fid = priv;

	struct p9_fid *fid = rreq->netfs_priv;

	p9_client_clunk(fid);

}

const struct netfs_request_ops v9fs_req_ops = {

	.init_request		= v9fs_init_request,

	.free_request		= v9fs_free_request,

	.begin_cache_operation	= v9fs_begin_cache_operation,

	.issue_read		= v9fs_issue_read,

	.cleanup		= v9fs_req_cleanup,

};

/**

	 * 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, &folio, fsdata);

	retval = netfs_write_begin(&v9inode->netfs, filp, mapping, pos, len, &folio, fsdata);

	if (retval < 0)

		return retval;

 */

static void v9fs_set_netfs_context(struct inode *inode)

{

	netfs_inode_init(inode, &v9fs_req_ops);

	struct v9fs_inode *v9inode = V9FS_I(inode);

	netfs_inode_init(&v9inode->netfs, &v9fs_req_ops);

}

int v9fs_init_inode(struct v9fs_session_info *v9ses,

	/* there shouldn't be an existing inode */

	BUG_ON(!(inode->i_state & I_NEW));

	netfs_inode_init(inode, NULL);

	netfs_inode_init(&vnode->netfs, NULL);

	inode->i_size		= 0;

	inode->i_mode		= S_IFDIR | S_IRUGO | S_IXUGO;

	if (root) {