[net-next-2.6.git] / fs / afs / cache.c

/* AFS caching stuff
 *
 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/slab.h>
#include <linux/sched.h>
#include "internal.h"

static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
				       void *buffer, uint16_t buflen);
static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data,
				       void *buffer, uint16_t buflen);
static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data,
						      const void *buffer,
						      uint16_t buflen);

static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data,
					    void *buffer, uint16_t buflen);
static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data,
					    void *buffer, uint16_t buflen);
static enum fscache_checkaux afs_vlocation_cache_check_aux(
	void *cookie_netfs_data, const void *buffer, uint16_t buflen);

static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
					 void *buffer, uint16_t buflen);

static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
					void *buffer, uint16_t buflen);
static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
				     uint64_t *size);
static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
					void *buffer, uint16_t buflen);
static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
						       const void *buffer,
						       uint16_t buflen);
static void afs_vnode_cache_now_uncached(void *cookie_netfs_data);

struct fscache_netfs afs_cache_netfs = {
	.name			= "afs",
	.version		= 0,
};

struct fscache_cookie_def afs_cell_cache_index_def = {
	.name		= "AFS.cell",
	.type		= FSCACHE_COOKIE_TYPE_INDEX,
	.get_key	= afs_cell_cache_get_key,
	.get_aux	= afs_cell_cache_get_aux,
	.check_aux	= afs_cell_cache_check_aux,
};

struct fscache_cookie_def afs_vlocation_cache_index_def = {
	.name			= "AFS.vldb",
	.type			= FSCACHE_COOKIE_TYPE_INDEX,
	.get_key		= afs_vlocation_cache_get_key,
	.get_aux		= afs_vlocation_cache_get_aux,
	.check_aux		= afs_vlocation_cache_check_aux,
};

struct fscache_cookie_def afs_volume_cache_index_def = {
	.name		= "AFS.volume",
	.type		= FSCACHE_COOKIE_TYPE_INDEX,
	.get_key	= afs_volume_cache_get_key,
};

struct fscache_cookie_def afs_vnode_cache_index_def = {
	.name			= "AFS.vnode",
	.type			= FSCACHE_COOKIE_TYPE_DATAFILE,
	.get_key		= afs_vnode_cache_get_key,
	.get_attr		= afs_vnode_cache_get_attr,
	.get_aux		= afs_vnode_cache_get_aux,
	.check_aux		= afs_vnode_cache_check_aux,
	.now_uncached		= afs_vnode_cache_now_uncached,
};

/*
 * set the key for the index entry
 */
static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
				       void *buffer, uint16_t bufmax)
{
	const struct afs_cell *cell = cookie_netfs_data;
	uint16_t klen;

	_enter("%p,%p,%u", cell, buffer, bufmax);

	klen = strlen(cell->name);
	if (klen > bufmax)
		return 0;

	memcpy(buffer, cell->name, klen);
	return klen;
}

/*
 * provide new auxilliary cache data
 */
static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data,
				       void *buffer, uint16_t bufmax)
{
	const struct afs_cell *cell = cookie_netfs_data;
	uint16_t dlen;

	_enter("%p,%p,%u", cell, buffer, bufmax);

	dlen = cell->vl_naddrs * sizeof(cell->vl_addrs[0]);
	dlen = min(dlen, bufmax);
	dlen &= ~(sizeof(cell->vl_addrs[0]) - 1);

	memcpy(buffer, cell->vl_addrs, dlen);
	return dlen;
}

/*
 * check that the auxilliary data indicates that the entry is still valid
 */
static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data,
						      const void *buffer,
						      uint16_t buflen)
{
	_leave(" = OKAY");
	return FSCACHE_CHECKAUX_OKAY;
}

/*****************************************************************************/
/*
 * set the key for the index entry
 */
static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data,
					    void *buffer, uint16_t bufmax)
{
	const struct afs_vlocation *vlocation = cookie_netfs_data;
	uint16_t klen;

	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);

	klen = strnlen(vlocation->vldb.name, sizeof(vlocation->vldb.name));
	if (klen > bufmax)
		return 0;

	memcpy(buffer, vlocation->vldb.name, klen);

	_leave(" = %u", klen);
	return klen;
}

/*
 * provide new auxilliary cache data
 */
static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data,
					    void *buffer, uint16_t bufmax)
{
	const struct afs_vlocation *vlocation = cookie_netfs_data;
	uint16_t dlen;

	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);

	dlen = sizeof(struct afs_cache_vlocation);
	dlen -= offsetof(struct afs_cache_vlocation, nservers);
	if (dlen > bufmax)
		return 0;

	memcpy(buffer, (uint8_t *)&vlocation->vldb.nservers, dlen);

	_leave(" = %u", dlen);
	return dlen;
}

/*
 * check that the auxilliary data indicates that the entry is still valid
 */
static
enum fscache_checkaux afs_vlocation_cache_check_aux(void *cookie_netfs_data,
						    const void *buffer,
						    uint16_t buflen)
{
	const struct afs_cache_vlocation *cvldb;
	struct afs_vlocation *vlocation = cookie_netfs_data;
	uint16_t dlen;

	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, buflen);

	/* check the size of the data is what we're expecting */
	dlen = sizeof(struct afs_cache_vlocation);
	dlen -= offsetof(struct afs_cache_vlocation, nservers);
	if (dlen != buflen)
		return FSCACHE_CHECKAUX_OBSOLETE;

	cvldb = container_of(buffer, struct afs_cache_vlocation, nservers);

	/* if what's on disk is more valid than what's in memory, then use the
	 * VL record from the cache */
	if (!vlocation->valid || vlocation->vldb.rtime == cvldb->rtime) {
		memcpy((uint8_t *)&vlocation->vldb.nservers, buffer, dlen);
		vlocation->valid = 1;
		_leave(" = SUCCESS [c->m]");
		return FSCACHE_CHECKAUX_OKAY;
	}

	/* need to update the cache if the cached info differs */
	if (memcmp(&vlocation->vldb, buffer, dlen) != 0) {
		/* delete if the volume IDs for this name differ */
		if (memcmp(&vlocation->vldb.vid, &cvldb->vid,
			   sizeof(cvldb->vid)) != 0
		    ) {
			_leave(" = OBSOLETE");
			return FSCACHE_CHECKAUX_OBSOLETE;
		}

		_leave(" = UPDATE");
		return FSCACHE_CHECKAUX_NEEDS_UPDATE;
	}

	_leave(" = OKAY");
	return FSCACHE_CHECKAUX_OKAY;
}

/*****************************************************************************/
/*
 * set the key for the volume index entry
 */
static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
					void *buffer, uint16_t bufmax)
{
	const struct afs_volume *volume = cookie_netfs_data;
	uint16_t klen;

	_enter("{%u},%p,%u", volume->type, buffer, bufmax);

	klen = sizeof(volume->type);
	if (klen > bufmax)
		return 0;

	memcpy(buffer, &volume->type, sizeof(volume->type));

	_leave(" = %u", klen);
	return klen;

}

/*****************************************************************************/
/*
 * set the key for the index entry
 */
static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
					void *buffer, uint16_t bufmax)
{
	const struct afs_vnode *vnode = cookie_netfs_data;
	uint16_t klen;

	_enter("{%x,%x,%llx},%p,%u",
	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
	       buffer, bufmax);

	klen = sizeof(vnode->fid.vnode);
	if (klen > bufmax)
		return 0;

	memcpy(buffer, &vnode->fid.vnode, sizeof(vnode->fid.vnode));

	_leave(" = %u", klen);
	return klen;
}

/*
 * 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;
}

/*
 * provide new auxilliary cache data
 */
static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
					void *buffer, uint16_t bufmax)
{
	const struct afs_vnode *vnode = cookie_netfs_data;
	uint16_t dlen;

	_enter("{%x,%x,%Lx},%p,%u",
	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
	       buffer, bufmax);

	dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
	if (dlen > bufmax)
		return 0;

	memcpy(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique));
	buffer += sizeof(vnode->fid.unique);
	memcpy(buffer, &vnode->status.data_version,
	       sizeof(vnode->status.data_version));

	_leave(" = %u", dlen);
	return dlen;
}

/*
 * check that the auxilliary 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)
{
	struct afs_vnode *vnode = cookie_netfs_data;
	uint16_t dlen;

	_enter("{%x,%x,%llx},%p,%u",
	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
	       buffer, buflen);

	/* check the size of the data is what we're expecting */
	dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
	if (dlen != buflen) {
		_leave(" = OBSOLETE [len %hx != %hx]", dlen, buflen);
		return FSCACHE_CHECKAUX_OBSOLETE;
	}

	if (memcmp(buffer,
		   &vnode->fid.unique,
		   sizeof(vnode->fid.unique)
		   ) != 0) {
		unsigned unique;

		memcpy(&unique, buffer, sizeof(unique));

		_leave(" = OBSOLETE [uniq %x != %x]",
		       unique, vnode->fid.unique);
		return FSCACHE_CHECKAUX_OBSOLETE;
	}

	if (memcmp(buffer + sizeof(vnode->fid.unique),
		   &vnode->status.data_version,
		   sizeof(vnode->status.data_version)
		   ) != 0) {
		afs_dataversion_t version;

		memcpy(&version, buffer + sizeof(vnode->fid.unique),
		       sizeof(version));

		_leave(" = OBSOLETE [vers %llx != %llx]",
		       version, vnode->status.data_version);
		return FSCACHE_CHECKAUX_OBSOLETE;
	}

	_leave(" = SUCCESS");
	return FSCACHE_CHECKAUX_OKAY;
}

/*
 * indication the cookie is no longer uncached
 * - this function is called when the backing store currently caching a cookie
 *   is removed
 * - the netfs should use this to clean up any markers indicating cached pages
 * - this is mandatory for any object that may have data
 */
static void afs_vnode_cache_now_uncached(void *cookie_netfs_data)
{
	struct afs_vnode *vnode = cookie_netfs_data;
	struct pagevec pvec;
	pgoff_t first;
	int loop, nr_pages;

	_enter("{%x,%x,%Lx}",
	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version);

	pagevec_init(&pvec, 0);
	first = 0;

	for (;;) {
		/* grab a bunch of pages to clean */
		nr_pages = pagevec_lookup(&pvec, vnode->vfs_inode.i_mapping,
					  first,
					  PAGEVEC_SIZE - pagevec_count(&pvec));
		if (!nr_pages)
			break;

		for (loop = 0; loop < nr_pages; loop++)
			ClearPageFsCache(pvec.pages[loop]);

		first = pvec.pages[nr_pages - 1]->index + 1;

		pvec.nr = nr_pages;
		pagevec_release(&pvec);
		cond_resched();
	}

	_leave("");
}
Commit	Line	Data
08e0e7c8 DH	1	/* AFS caching stuff
08e0e7c8 DH	2	*
9b3f26c9	3	* Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
08e0e7c8 DH	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
9b3f26c9 DH	12	#include <linux/slab.h>
	13	#include <linux/sched.h>
	14	#include "internal.h"
	15
	16	static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
	17	void *buffer, uint16_t buflen);
	18	static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data,
	19	void *buffer, uint16_t buflen);
	20	static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data,
	21	const void *buffer,
	22	uint16_t buflen);
	23
	24	static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data,
	25	void *buffer, uint16_t buflen);
	26	static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data,
	27	void *buffer, uint16_t buflen);
	28	static enum fscache_checkaux afs_vlocation_cache_check_aux(
	29	void cookie_netfs_data, const void buffer, uint16_t buflen);
	30
	31	static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
	32	void *buffer, uint16_t buflen);
	33
	34	static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
	35	void *buffer, uint16_t buflen);
	36	static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
	37	uint64_t *size);
	38	static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
	39	void *buffer, uint16_t buflen);
	40	static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
	41	const void *buffer,
	42	uint16_t buflen);
	43	static void afs_vnode_cache_now_uncached(void *cookie_netfs_data);
	44
	45	struct fscache_netfs afs_cache_netfs = {
	46	.name = "afs",
	47	.version = 0,
	48	};
	49
	50	struct fscache_cookie_def afs_cell_cache_index_def = {
	51	.name = "AFS.cell",
	52	.type = FSCACHE_COOKIE_TYPE_INDEX,
	53	.get_key = afs_cell_cache_get_key,
	54	.get_aux = afs_cell_cache_get_aux,
	55	.check_aux = afs_cell_cache_check_aux,
	56	};
	57
	58	struct fscache_cookie_def afs_vlocation_cache_index_def = {
	59	.name = "AFS.vldb",
	60	.type = FSCACHE_COOKIE_TYPE_INDEX,
	61	.get_key = afs_vlocation_cache_get_key,
	62	.get_aux = afs_vlocation_cache_get_aux,
	63	.check_aux = afs_vlocation_cache_check_aux,
	64	};
	65
	66	struct fscache_cookie_def afs_volume_cache_index_def = {
	67	.name = "AFS.volume",
	68	.type = FSCACHE_COOKIE_TYPE_INDEX,
	69	.get_key = afs_volume_cache_get_key,
	70	};
	71
	72	struct fscache_cookie_def afs_vnode_cache_index_def = {
	73	.name = "AFS.vnode",
	74	.type = FSCACHE_COOKIE_TYPE_DATAFILE,
	75	.get_key = afs_vnode_cache_get_key,
76	.get_attr = afs_vnode_cache_get_attr,
77	.get_aux = afs_vnode_cache_get_aux,
78	.check_aux = afs_vnode_cache_check_aux,
79	.now_uncached = afs_vnode_cache_now_uncached,
08e0e7c8	80	};
08e0e7c8 DH	81
08e0e7c8 DH	82	/*
9b3f26c9	83	* set the key for the index entry
08e0e7c8	84	*/
9b3f26c9 DH	85	static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
9b3f26c9 DH	86	void *buffer, uint16_t bufmax)
08e0e7c8	87	{
9b3f26c9 DH	88	const struct afs_cell *cell = cookie_netfs_data;
9b3f26c9 DH	89	uint16_t klen;
08e0e7c8	90
9b3f26c9	91	_enter("%p,%p,%u", cell, buffer, bufmax);
08e0e7c8	92
9b3f26c9 DH	93	klen = strlen(cell->name);
	94	if (klen > bufmax)
	95	return 0;
08e0e7c8	96
9b3f26c9 DH	97	memcpy(buffer, cell->name, klen);
9b3f26c9 DH	98	return klen;
08e0e7c8	99	}
08e0e7c8 DH	100
08e0e7c8 DH	101	/*
9b3f26c9	102	* provide new auxilliary cache data
08e0e7c8	103	*/
9b3f26c9 DH	104	static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data,
9b3f26c9 DH	105	void *buffer, uint16_t bufmax)
08e0e7c8	106	{
9b3f26c9 DH	107	const struct afs_cell *cell = cookie_netfs_data;
9b3f26c9 DH	108	uint16_t dlen;
08e0e7c8	109
9b3f26c9	110	_enter("%p,%p,%u", cell, buffer, bufmax);
08e0e7c8	111
9b3f26c9 DH	112	dlen = cell->vl_naddrs * sizeof(cell->vl_addrs[0]);
	113	dlen = min(dlen, bufmax);
	114	dlen &= ~(sizeof(cell->vl_addrs[0]) - 1);
08e0e7c8	115
9b3f26c9 DH	116	memcpy(buffer, cell->vl_addrs, dlen);
	117	return dlen;
	118	}
08e0e7c8	119
9b3f26c9 DH	120	/*
	121	* check that the auxilliary data indicates that the entry is still valid
	122	*/
	123	static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data,
	124	const void *buffer,
	125	uint16_t buflen)
	126	{
	127	_leave(" = OKAY");
	128	return FSCACHE_CHECKAUX_OKAY;
08e0e7c8	129	}
08e0e7c8	130
9b3f26c9	131	/*****************************************************************************/
08e0e7c8	132	/*
9b3f26c9	133	* set the key for the index entry
08e0e7c8	134	*/
9b3f26c9 DH	135	static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data,
9b3f26c9 DH	136	void *buffer, uint16_t bufmax)
08e0e7c8	137	{
9b3f26c9 DH	138	const struct afs_vlocation *vlocation = cookie_netfs_data;
	139	uint16_t klen;
	140
	141	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);
	142
	143	klen = strnlen(vlocation->vldb.name, sizeof(vlocation->vldb.name));
	144	if (klen > bufmax)
	145	return 0;
08e0e7c8	146
9b3f26c9	147	memcpy(buffer, vlocation->vldb.name, klen);
08e0e7c8	148
9b3f26c9 DH	149	_leave(" = %u", klen);
	150	return klen;
	151	}
	152
	153	/*
	154	* provide new auxilliary cache data
	155	*/
	156	static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data,
	157	void *buffer, uint16_t bufmax)
	158	{
	159	const struct afs_vlocation *vlocation = cookie_netfs_data;
	160	uint16_t dlen;
	161
	162	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);
	163
	164	dlen = sizeof(struct afs_cache_vlocation);
	165	dlen -= offsetof(struct afs_cache_vlocation, nservers);
	166	if (dlen > bufmax)
	167	return 0;
	168
	169	memcpy(buffer, (uint8_t *)&vlocation->vldb.nservers, dlen);
	170
	171	_leave(" = %u", dlen);
	172	return dlen;
	173	}
	174
	175	/*
	176	* check that the auxilliary data indicates that the entry is still valid
	177	*/
	178	static
	179	enum fscache_checkaux afs_vlocation_cache_check_aux(void *cookie_netfs_data,
	180	const void *buffer,
	181	uint16_t buflen)
	182	{
	183	const struct afs_cache_vlocation *cvldb;
	184	struct afs_vlocation *vlocation = cookie_netfs_data;
	185	uint16_t dlen;
	186
	187	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, buflen);
	188
	189	/* check the size of the data is what we're expecting */
	190	dlen = sizeof(struct afs_cache_vlocation);
	191	dlen -= offsetof(struct afs_cache_vlocation, nservers);
	192	if (dlen != buflen)
	193	return FSCACHE_CHECKAUX_OBSOLETE;
	194
	195	cvldb = container_of(buffer, struct afs_cache_vlocation, nservers);
	196
	197	/* if what's on disk is more valid than what's in memory, then use the
	198	* VL record from the cache */
	199	if (!vlocation->valid \|\| vlocation->vldb.rtime == cvldb->rtime) {
	200	memcpy((uint8_t *)&vlocation->vldb.nservers, buffer, dlen);
	201	vlocation->valid = 1;
	202	_leave(" = SUCCESS [c->m]");
	203	return FSCACHE_CHECKAUX_OKAY;
	204	}
	205
	206	/* need to update the cache if the cached info differs */
	207	if (memcmp(&vlocation->vldb, buffer, dlen) != 0) {
	208	/* delete if the volume IDs for this name differ */
	209	if (memcmp(&vlocation->vldb.vid, &cvldb->vid,
	210	sizeof(cvldb->vid)) != 0
08e0e7c8	211	) {
9b3f26c9 DH	212	_leave(" = OBSOLETE");
9b3f26c9 DH	213	return FSCACHE_CHECKAUX_OBSOLETE;
08e0e7c8	214	}
9b3f26c9 DH	215
	216	_leave(" = UPDATE");
	217	return FSCACHE_CHECKAUX_NEEDS_UPDATE;
08e0e7c8 DH	218	}
08e0e7c8 DH	219
9b3f26c9 DH	220	_leave(" = OKAY");
9b3f26c9 DH	221	return FSCACHE_CHECKAUX_OKAY;
08e0e7c8	222	}
08e0e7c8	223
9b3f26c9	224	/*****************************************************************************/
08e0e7c8	225	/*
9b3f26c9	226	* set the key for the volume index entry
08e0e7c8	227	*/
9b3f26c9 DH	228	static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
9b3f26c9 DH	229	void *buffer, uint16_t bufmax)
08e0e7c8	230	{
9b3f26c9 DH	231	const struct afs_volume *volume = cookie_netfs_data;
	232	uint16_t klen;
	233
	234	_enter("{%u},%p,%u", volume->type, buffer, bufmax);
	235
	236	klen = sizeof(volume->type);
	237	if (klen > bufmax)
	238	return 0;
08e0e7c8	239
9b3f26c9 DH	240	memcpy(buffer, &volume->type, sizeof(volume->type));
	241
	242	_leave(" = %u", klen);
	243	return klen;
08e0e7c8	244
08e0e7c8	245	}
08e0e7c8	246
9b3f26c9	247	/*****************************************************************************/
08e0e7c8	248	/*
9b3f26c9	249	* set the key for the index entry
08e0e7c8	250	*/
9b3f26c9 DH	251	static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
9b3f26c9 DH	252	void *buffer, uint16_t bufmax)
08e0e7c8	253	{
9b3f26c9 DH	254	const struct afs_vnode *vnode = cookie_netfs_data;
9b3f26c9 DH	255	uint16_t klen;
08e0e7c8	256
9b3f26c9 DH	257	_enter("{%x,%x,%llx},%p,%u",
	258	vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
	259	buffer, bufmax);
08e0e7c8	260
9b3f26c9 DH	261	klen = sizeof(vnode->fid.vnode);
	262	if (klen > bufmax)
	263	return 0;
	264
	265	memcpy(buffer, &vnode->fid.vnode, sizeof(vnode->fid.vnode));
08e0e7c8	266
9b3f26c9 DH	267	_leave(" = %u", klen);
9b3f26c9 DH	268	return klen;
08e0e7c8	269	}
08e0e7c8 DH	270
08e0e7c8 DH	271	/*
9b3f26c9	272	* provide updated file attributes
08e0e7c8	273	*/
9b3f26c9 DH	274	static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
9b3f26c9 DH	275	uint64_t *size)
08e0e7c8	276	{
9b3f26c9	277	const struct afs_vnode *vnode = cookie_netfs_data;
08e0e7c8	278
9b3f26c9 DH	279	_enter("{%x,%x,%llx},",
	280	vnode->fid.vnode, vnode->fid.unique,
	281	vnode->status.data_version);
08e0e7c8	282
9b3f26c9	283	*size = vnode->status.size;
08e0e7c8	284	}
08e0e7c8 DH	285
08e0e7c8 DH	286	/*
9b3f26c9 DH	287	* provide new auxilliary cache data
	288	*/
	289	static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
	290	void *buffer, uint16_t bufmax)
	291	{
	292	const struct afs_vnode *vnode = cookie_netfs_data;
	293	uint16_t dlen;
	294
	295	_enter("{%x,%x,%Lx},%p,%u",
	296	vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
	297	buffer, bufmax);
	298
	299	dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
	300	if (dlen > bufmax)
	301	return 0;
	302
	303	memcpy(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique));
	304	buffer += sizeof(vnode->fid.unique);
	305	memcpy(buffer, &vnode->status.data_version,
	306	sizeof(vnode->status.data_version));
	307
	308	_leave(" = %u", dlen);
	309	return dlen;
	310	}
	311
	312	/*
	313	* check that the auxilliary data indicates that the entry is still valid
08e0e7c8	314	*/
9b3f26c9 DH	315	static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
	316	const void *buffer,
	317	uint16_t buflen)
08e0e7c8	318	{
9b3f26c9 DH	319	struct afs_vnode *vnode = cookie_netfs_data;
	320	uint16_t dlen;
	321
	322	_enter("{%x,%x,%llx},%p,%u",
	323	vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
	324	buffer, buflen);
	325
	326	/* check the size of the data is what we're expecting */
	327	dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
	328	if (dlen != buflen) {
	329	_leave(" = OBSOLETE [len %hx != %hx]", dlen, buflen);
	330	return FSCACHE_CHECKAUX_OBSOLETE;
08e0e7c8 DH	331	}
08e0e7c8 DH	332
9b3f26c9 DH	333	if (memcmp(buffer,
	334	&vnode->fid.unique,
	335	sizeof(vnode->fid.unique)
	336	) != 0) {
	337	unsigned unique;
	338
	339	memcpy(&unique, buffer, sizeof(unique));
	340
	341	_leave(" = OBSOLETE [uniq %x != %x]",
	342	unique, vnode->fid.unique);
	343	return FSCACHE_CHECKAUX_OBSOLETE;
	344	}
	345
	346	if (memcmp(buffer + sizeof(vnode->fid.unique),
	347	&vnode->status.data_version,
	348	sizeof(vnode->status.data_version)
	349	) != 0) {
	350	afs_dataversion_t version;
	351
	352	memcpy(&version, buffer + sizeof(vnode->fid.unique),
	353	sizeof(version));
	354
	355	_leave(" = OBSOLETE [vers %llx != %llx]",
	356	version, vnode->status.data_version);
	357	return FSCACHE_CHECKAUX_OBSOLETE;
08e0e7c8 DH	358	}
	359
	360	_leave(" = SUCCESS");
9b3f26c9	361	return FSCACHE_CHECKAUX_OKAY;
08e0e7c8	362	}
08e0e7c8 DH	363
08e0e7c8 DH	364	/*
9b3f26c9 DH	365	* indication the cookie is no longer uncached
	366	* - this function is called when the backing store currently caching a cookie
	367	* is removed
	368	* - the netfs should use this to clean up any markers indicating cached pages
	369	* - this is mandatory for any object that may have data
08e0e7c8	370	*/
9b3f26c9	371	static void afs_vnode_cache_now_uncached(void *cookie_netfs_data)
08e0e7c8	372	{
9b3f26c9 DH	373	struct afs_vnode *vnode = cookie_netfs_data;
	374	struct pagevec pvec;
	375	pgoff_t first;
	376	int loop, nr_pages;
	377
	378	_enter("{%x,%x,%Lx}",
	379	vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version);
	380
	381	pagevec_init(&pvec, 0);
	382	first = 0;
	383
	384	for (;;) {
	385	/* grab a bunch of pages to clean */
	386	nr_pages = pagevec_lookup(&pvec, vnode->vfs_inode.i_mapping,
	387	first,
	388	PAGEVEC_SIZE - pagevec_count(&pvec));
	389	if (!nr_pages)
	390	break;
08e0e7c8	391
9b3f26c9 DH	392	for (loop = 0; loop < nr_pages; loop++)
	393	ClearPageFsCache(pvec.pages[loop]);
	394
	395	first = pvec.pages[nr_pages - 1]->index + 1;
	396
	397	pvec.nr = nr_pages;
	398	pagevec_release(&pvec);
	399	cond_resched();
	400	}
08e0e7c8	401
9b3f26c9	402	_leave("");
08e0e7c8	403	}