fscache: Pass object size in rather than calling back for it

			const void *parent_netfs_data,

			const void *cookie_netfs_data);

		void (*get_attr)(const void *cookie_netfs_data,

				 uint64_t *size);

		enum fscache_checkaux (*check_aux)(void *cookie_netfs_data,

						   const void *data,

						   uint16_t datalen);

						   uint16_t datalen,

						   loff_t object_size);

		void (*get_context)(void *cookie_netfs_data, void *context);

     cache in the parent's list will be chosen, or failing that, the first

     cache in the master list.

 (4) A function to retrieve attribute data from the netfs [optional].

     This function will be called with the netfs data that was passed to the

     cookie acquisition function.  It should return the size of the file if

     this is a data file.  The size may be used to govern how much cache must

     be reserved for this file in the cache.

     If the function is absent, a file size of 0 is assumed.

 (5) A function to check the auxiliary data [optional].

 (4) A function to check the auxiliary data [optional].

     This function will be called to check that a match found in the cache for

     this object is valid.  For instance with AFS it could check the auxiliary

     If this function is absent, it will be assumed that matching objects in a

     cache are always valid.

     The function is also passed the cache's idea of the object size and may

     use this to manage coherency also.

     If present, the function should return one of the following values:

	(*) FSCACHE_CHECKAUX_OKAY		- the entry is okay as is

     This function can also be used to extract data from the auxiliary data in

     the cache and copy it into the netfs's structures.

 (6) A pair of functions to manage contexts for the completion callback

 (5) A pair of functions to manage contexts for the completion callback

     [optional].

     The cache read/write functions are passed a context which is then passed

     required for indices as indices may not contain data.  These functions may

     be called in interrupt context and so may not sleep.

 (7) A function to mark a page as retaining cache metadata [optional].

 (6) A function to mark a page as retaining cache metadata [optional].

     This is called by the cache to indicate that it is retaining in-memory

     information for this page and that the netfs should uncache the page when

     This function is not required for indices as they're not permitted data.

 (8) A function to unmark all the pages retaining cache metadata [mandatory].

 (7) A function to unmark all the pages retaining cache metadata [mandatory].

     This is called by FS-Cache to indicate that a backing store is being

     unbound from a cookie and that all the marks on the pages should be

			       const void *aux_data,

			       size_t aux_data_len,

			       void *netfs_data,

			       loff_t object_size,

			       bool enable);

This function creates an index entry in the index represented by parent,

to it in the event of any calling back.  This may also be used in tracing or

logging of messages.

The cache tracks the size of the data attached to an object and this set to be

object_size.  For indices, this should be 0.  This value will be passed to the

->check_aux() callback.

Note that this function never returns an error - all errors are handled

internally.  It may, however, return NULL to indicate no cookie.  It is quite

acceptable to pass this token back to this function as the parent to another

				       &afs_cell_cache_index_def,

				       cell->name, strlen(cell->name),

				       NULL, 0,

				       cell, true);

				       cell, 0, true);

And then a particular volume could be added to that index by ID, creating

another index for vnodes (AFS inode equivalents):

				       &afs_volume_cache_index_def,

				       &volume->vid, sizeof(volume->vid),

				       NULL, 0,

				       volume, true);

				       volume, 0, true);

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

				       &afs_vnode_cache_object_def,

				       &key, sizeof(key),

				       &aux, sizeof(aux),

				       vnode, true);

				       vnode, vnode->status.size, true);

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

				       &afs_xattr_cache_object_def,

				       &xattr->name, strlen(xattr->name),

				       NULL, 0,

				       xattr, true);

				       xattr, strlen(xattr->val), true);

Miscellaneous objects might be used to store extended attributes or directory

entries for example.

	int fscache_attr_changed(struct fscache_cookie *cookie);

The cache will return -ENOBUFS if there is no backing cache or if there is no

space to allocate any extra metadata required in the cache.  The attributes

will be accessed with the get_attr() cookie definition operation.

space to allocate any extra metadata required in the cache.

Note that attempts to read or write data pages in the cache over this size may

be rebuffed with -ENOBUFS.

	int fscache_write_page(struct fscache_cookie *cookie,

			       struct page *page,

			       loff_t object_size,

			       gfp_t gfp);

The cookie argument must specify a data file cookie, the page specified should

contain the data to be written (and is also used to specify the page number),

and the gfp argument is used to control how any memory allocations made are

satisfied.

object_size is the revised size of the object and the gfp argument is used to

control how any memory allocations made are satisfied.

The page must have first been read or allocated successfully and must not have

been uncached before writing is performed.

    	void fscache_enable_cookie(struct fscache_cookie *cookie,

				   const void *aux_data,

				   loff_t object_size,

    				   bool (*can_enable)(void *data),

    				   void *data)

All possible failures are handled internally.  The cookie will only be marked

as enabled if provisional backing objects are allocated.

The object's data size is updated from object_size and is passed to the

->check_aux() function.

In both cases, the cookie's auxiliary data buffer is updated from aux_data if

that is non-NULL inside the enablement lock before proceeding.

						v9ses->cachetag,

						strlen(v9ses->cachetag),

						NULL, 0,

						v9ses, true);

						v9ses, 0, true);

	p9_debug(P9_DEBUG_FSC, "session %p get cookie %p\n",

		 v9ses, v9ses->fscache);

}

	v9ses->fscache = NULL;

}

static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,

				      uint64_t *size)

{

	const struct v9fs_inode *v9inode = cookie_netfs_data;

	*size = i_size_read(&v9inode->vfs_inode);

	p9_debug(P9_DEBUG_FSC, "inode %p get attr %llu\n",

		 &v9inode->vfs_inode, *size);

}

static enum

fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,

					    const void *buffer,

					    uint16_t buflen)

					    uint16_t buflen,

					    loff_t object_size)

{

	const struct v9fs_inode *v9inode = cookie_netfs_data;

const struct fscache_cookie_def v9fs_cache_inode_index_def = {

	.name		= "9p.inode",

	.type		= FSCACHE_COOKIE_TYPE_DATAFILE,

	.get_attr	= v9fs_cache_inode_get_attr,

	.check_aux	= v9fs_cache_inode_check_aux,

};

						  sizeof(v9inode->qid.path),

						  &v9inode->qid.version,

						  sizeof(v9inode->qid.version),

						  v9inode, true);

						  v9inode,

						  i_size_read(&v9inode->vfs_inode),

						  true);

	p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",

		 inode, v9inode->fscache);

						  sizeof(v9inode->qid.path),

						  &v9inode->qid.version,

						  sizeof(v9inode->qid.version),

						  v9inode, true);

						  v9inode,

						  i_size_read(&v9inode->vfs_inode),

						  true);

	p9_debug(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p\n",

		 inode, old, v9inode->fscache);

	const struct v9fs_inode *v9inode = V9FS_I(inode);

	p9_debug(P9_DEBUG_FSC, "inode %p page %p\n", inode, page);

	ret = fscache_write_page(v9inode->fscache, page, GFP_KERNEL);

	ret = fscache_write_page(v9inode->fscache, page,

				 i_size_read(&v9inode->vfs_inode), GFP_KERNEL);

	p9_debug(P9_DEBUG_FSC, "ret =  %d\n", ret);

	if (ret != 0)

		v9fs_uncache_page(inode, page);

#include <linux/sched.h>

#include "internal.h"

static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,

				     uint64_t *size);

static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,

						       const void *buffer,

						       uint16_t buflen);

						       uint16_t buflen,

						       loff_t object_size);

struct fscache_netfs afs_cache_netfs = {

	.name			= "afs",

struct fscache_cookie_def afs_vnode_cache_index_def = {

	.name		= "AFS.vnode",

	.type		= FSCACHE_COOKIE_TYPE_DATAFILE,

	.get_attr	= afs_vnode_cache_get_attr,

	.check_aux	= afs_vnode_cache_check_aux,

};

/*

 * provide updated file attributes

 */

static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,

				     uint64_t *size)

{

	const struct afs_vnode *vnode = cookie_netfs_data;

	_enter("{%x,%x,%llx},",

	       vnode->fid.vnode, vnode->fid.unique,

	       vnode->status.data_version);

	*size = vnode->status.size;

}

/*

 * check that the auxiliary data indicates that the entry is still valid

 */

static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,

						       const void *buffer,

						       uint16_t buflen)

						       uint16_t buflen,

						       loff_t object_size)

{

	struct afs_vnode *vnode = cookie_netfs_data;

	struct afs_vnode_cache_aux aux;

					     &afs_cell_cache_index_def,

					     cell->name, strlen(cell->name),

					     NULL, 0,

					     cell, true);

					     cell, 0, true);

#endif

	ret = afs_proc_cell_setup(net, cell);

	if (ret < 0)

		/* send the page to the cache */

#ifdef CONFIG_AFS_FSCACHE

		if (PageFsCache(page) &&

		    fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {

		    fscache_write_page(vnode->cache, page, vnode->status.size,

				       GFP_KERNEL) != 0) {

			fscache_uncache_page(vnode->cache, page);

			BUG_ON(PageFsCache(page));

		}

	/* send the page to the cache */

#ifdef CONFIG_AFS_FSCACHE

	if (PageFsCache(page) &&

	    fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) {

	    fscache_write_page(vnode->cache, page, vnode->status.size,

			       GFP_KERNEL) != 0) {

		fscache_uncache_page(vnode->cache, page);

		BUG_ON(PageFsCache(page));

	}