[linux.git] / fs / cachefiles / interface.c

/* FS-Cache interface to CacheFiles
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */

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

#define list_to_page(head) (list_entry((head)->prev, struct page, lru))

struct cachefiles_lookup_data {
	struct cachefiles_xattr	*auxdata;	/* auxiliary data */
	char			*key;		/* key path */
};

static int cachefiles_attr_changed(struct fscache_object *_object);

/*
 * allocate an object record for a cookie lookup and prepare the lookup data
 */
static struct fscache_object *cachefiles_alloc_object(
	struct fscache_cache *_cache,
	struct fscache_cookie *cookie)
{
	struct cachefiles_lookup_data *lookup_data;
	struct cachefiles_object *object;
	struct cachefiles_cache *cache;
	struct cachefiles_xattr *auxdata;
	unsigned keylen, auxlen;
	void *buffer;
	char *key;

	cache = container_of(_cache, struct cachefiles_cache, cache);

	_enter("{%s},%p,", cache->cache.identifier, cookie);

	lookup_data = kmalloc(sizeof(*lookup_data), cachefiles_gfp);
	if (!lookup_data)
		goto nomem_lookup_data;

	/* create a new object record and a temporary leaf image */
	object = kmem_cache_alloc(cachefiles_object_jar, cachefiles_gfp);
	if (!object)
		goto nomem_object;

	ASSERTCMP(object->backer, ==, NULL);

	BUG_ON(test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags));
	atomic_set(&object->usage, 1);

	fscache_object_init(&object->fscache, cookie, &cache->cache);

	object->type = cookie->def->type;

	/* get hold of the raw key
	 * - stick the length on the front and leave space on the back for the
	 *   encoder
	 */
	buffer = kmalloc((2 + 512) + 3, cachefiles_gfp);
	if (!buffer)
		goto nomem_buffer;

	keylen = cookie->def->get_key(cookie->netfs_data, buffer + 2, 512);
	ASSERTCMP(keylen, <, 512);

	*(uint16_t *)buffer = keylen;
	((char *)buffer)[keylen + 2] = 0;
	((char *)buffer)[keylen + 3] = 0;
	((char *)buffer)[keylen + 4] = 0;

	/* turn the raw key into something that can work with as a filename */
	key = cachefiles_cook_key(buffer, keylen + 2, object->type);
	if (!key)
		goto nomem_key;

	/* get hold of the auxiliary data and prepend the object type */
	auxdata = buffer;
	auxlen = 0;
	if (cookie->def->get_aux) {
		auxlen = cookie->def->get_aux(cookie->netfs_data,
					      auxdata->data, 511);
		ASSERTCMP(auxlen, <, 511);
	}

	auxdata->len = auxlen + 1;
	auxdata->type = cookie->def->type;

	lookup_data->auxdata = auxdata;
	lookup_data->key = key;
	object->lookup_data = lookup_data;

	_leave(" = %p [%p]", &object->fscache, lookup_data);
	return &object->fscache;

nomem_key:
	kfree(buffer);
nomem_buffer:
	BUG_ON(test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags));
	kmem_cache_free(cachefiles_object_jar, object);
	fscache_object_destroyed(&cache->cache);
nomem_object:
	kfree(lookup_data);
nomem_lookup_data:
	_leave(" = -ENOMEM");
	return ERR_PTR(-ENOMEM);
}

/*
 * attempt to look up the nominated node in this cache
 * - return -ETIMEDOUT to be scheduled again
 */
static int cachefiles_lookup_object(struct fscache_object *_object)
{
	struct cachefiles_lookup_data *lookup_data;
	struct cachefiles_object *parent, *object;
	struct cachefiles_cache *cache;
	const struct cred *saved_cred;
	int ret;

	_enter("{OBJ%x}", _object->debug_id);

	cache = container_of(_object->cache, struct cachefiles_cache, cache);
	parent = container_of(_object->parent,
			      struct cachefiles_object, fscache);
	object = container_of(_object, struct cachefiles_object, fscache);
	lookup_data = object->lookup_data;

	ASSERTCMP(lookup_data, !=, NULL);

	/* look up the key, creating any missing bits */
	cachefiles_begin_secure(cache, &saved_cred);
	ret = cachefiles_walk_to_object(parent, object,
					lookup_data->key,
					lookup_data->auxdata);
	cachefiles_end_secure(cache, saved_cred);

	/* polish off by setting the attributes of non-index files */
	if (ret == 0 &&
	    object->fscache.cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX)
		cachefiles_attr_changed(&object->fscache);

	if (ret < 0 && ret != -ETIMEDOUT) {
		if (ret != -ENOBUFS)
			printk(KERN_WARNING
			       "CacheFiles: Lookup failed error %d\n", ret);
		fscache_object_lookup_error(&object->fscache);
	}

	_leave(" [%d]", ret);
	return ret;
}

/*
 * indication of lookup completion
 */
static void cachefiles_lookup_complete(struct fscache_object *_object)
{
	struct cachefiles_object *object;

	object = container_of(_object, struct cachefiles_object, fscache);

	_enter("{OBJ%x,%p}", object->fscache.debug_id, object->lookup_data);

	if (object->lookup_data) {
		kfree(object->lookup_data->key);
		kfree(object->lookup_data->auxdata);
		kfree(object->lookup_data);
		object->lookup_data = NULL;
	}
}

/*
 * increment the usage count on an inode object (may fail if unmounting)
 */
static
struct fscache_object *cachefiles_grab_object(struct fscache_object *_object)
{
	struct cachefiles_object *object =
		container_of(_object, struct cachefiles_object, fscache);

	_enter("{OBJ%x,%d}", _object->debug_id, atomic_read(&object->usage));

#ifdef CACHEFILES_DEBUG_SLAB
	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
#endif

	atomic_inc(&object->usage);
	return &object->fscache;
}

/*
 * update the auxiliary data for an object object on disk
 */
static void cachefiles_update_object(struct fscache_object *_object)
{
	struct cachefiles_object *object;
	struct cachefiles_xattr *auxdata;
	struct cachefiles_cache *cache;
	struct fscache_cookie *cookie;
	const struct cred *saved_cred;
	unsigned auxlen;

	_enter("{OBJ%x}", _object->debug_id);

	object = container_of(_object, struct cachefiles_object, fscache);
	cache = container_of(object->fscache.cache, struct cachefiles_cache,
			     cache);
	cookie = object->fscache.cookie;

	if (!cookie->def->get_aux) {
		_leave(" [no aux]");
		return;
	}

	auxdata = kmalloc(2 + 512 + 3, cachefiles_gfp);
	if (!auxdata) {
		_leave(" [nomem]");
		return;
	}

	auxlen = cookie->def->get_aux(cookie->netfs_data, auxdata->data, 511);
	ASSERTCMP(auxlen, <, 511);

	auxdata->len = auxlen + 1;
	auxdata->type = cookie->def->type;

	cachefiles_begin_secure(cache, &saved_cred);
	cachefiles_update_object_xattr(object, auxdata);
	cachefiles_end_secure(cache, saved_cred);
	kfree(auxdata);
	_leave("");
}

/*
 * discard the resources pinned by an object and effect retirement if
 * requested
 */
static void cachefiles_drop_object(struct fscache_object *_object)
{
	struct cachefiles_object *object;
	struct cachefiles_cache *cache;
	const struct cred *saved_cred;

	ASSERT(_object);

	object = container_of(_object, struct cachefiles_object, fscache);

	_enter("{OBJ%x,%d}",
	       object->fscache.debug_id, atomic_read(&object->usage));

	cache = container_of(object->fscache.cache,
			     struct cachefiles_cache, cache);

#ifdef CACHEFILES_DEBUG_SLAB
	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
#endif

	/* delete retired objects */
	if (object->fscache.state == FSCACHE_OBJECT_RECYCLING &&
	    _object != cache->cache.fsdef
	    ) {
		_debug("- retire object OBJ%x", object->fscache.debug_id);
		cachefiles_begin_secure(cache, &saved_cred);
		cachefiles_delete_object(cache, object);
		cachefiles_end_secure(cache, saved_cred);
	}

	/* close the filesystem stuff attached to the object */
	if (object->backer != object->dentry)
		dput(object->backer);
	object->backer = NULL;

	/* note that the object is now inactive */
	if (test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
		write_lock(&cache->active_lock);
		if (!test_and_clear_bit(CACHEFILES_OBJECT_ACTIVE,
					&object->flags))
			BUG();
		rb_erase(&object->active_node, &cache->active_nodes);
		wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
		write_unlock(&cache->active_lock);
	}

	dput(object->dentry);
	object->dentry = NULL;

	_leave("");
}

/*
 * dispose of a reference to an object
 */
static void cachefiles_put_object(struct fscache_object *_object)
{
	struct cachefiles_object *object;
	struct fscache_cache *cache;

	ASSERT(_object);

	object = container_of(_object, struct cachefiles_object, fscache);

	_enter("{OBJ%x,%d}",
	       object->fscache.debug_id, atomic_read(&object->usage));

#ifdef CACHEFILES_DEBUG_SLAB
	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
#endif

	ASSERTIFCMP(object->fscache.parent,
		    object->fscache.parent->n_children, >, 0);

	if (atomic_dec_and_test(&object->usage)) {
		_debug("- kill object OBJ%x", object->fscache.debug_id);

		ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags));
		ASSERTCMP(object->fscache.parent, ==, NULL);
		ASSERTCMP(object->backer, ==, NULL);
		ASSERTCMP(object->dentry, ==, NULL);
		ASSERTCMP(object->fscache.n_ops, ==, 0);
		ASSERTCMP(object->fscache.n_children, ==, 0);

		if (object->lookup_data) {
			kfree(object->lookup_data->key);
			kfree(object->lookup_data->auxdata);
			kfree(object->lookup_data);
			object->lookup_data = NULL;
		}

		cache = object->fscache.cache;
		fscache_object_destroy(&object->fscache);
		kmem_cache_free(cachefiles_object_jar, object);
		fscache_object_destroyed(cache);
	}

	_leave("");
}

/*
 * sync a cache
 */
static void cachefiles_sync_cache(struct fscache_cache *_cache)
{
	struct cachefiles_cache *cache;
	const struct cred *saved_cred;
	int ret;

	_enter("%p", _cache);

	cache = container_of(_cache, struct cachefiles_cache, cache);

	/* make sure all pages pinned by operations on behalf of the netfs are
	 * written to disc */
	cachefiles_begin_secure(cache, &saved_cred);
	down_read(&cache->mnt->mnt_sb->s_umount);
	ret = sync_filesystem(cache->mnt->mnt_sb);
	up_read(&cache->mnt->mnt_sb->s_umount);
	cachefiles_end_secure(cache, saved_cred);

	if (ret == -EIO)
		cachefiles_io_error(cache,
				    "Attempt to sync backing fs superblock"
				    " returned error %d",
				    ret);
}

/*
 * notification the attributes on an object have changed
 * - called with reads/writes excluded by FS-Cache
 */
static int cachefiles_attr_changed(struct fscache_object *_object)
{
	struct cachefiles_object *object;
	struct cachefiles_cache *cache;
	const struct cred *saved_cred;
	struct iattr newattrs;
	uint64_t ni_size;
	loff_t oi_size;
	int ret;

	_object->cookie->def->get_attr(_object->cookie->netfs_data, &ni_size);

	_enter("{OBJ%x},[%llu]",
	       _object->debug_id, (unsigned long long) ni_size);

	object = container_of(_object, struct cachefiles_object, fscache);
	cache = container_of(object->fscache.cache,
			     struct cachefiles_cache, cache);

	if (ni_size == object->i_size)
		return 0;

	if (!object->backer)
		return -ENOBUFS;

	ASSERT(S_ISREG(object->backer->d_inode->i_mode));

	fscache_set_store_limit(&object->fscache, ni_size);

	oi_size = i_size_read(object->backer->d_inode);
	if (oi_size == ni_size)
		return 0;

	cachefiles_begin_secure(cache, &saved_cred);
	mutex_lock(&object->backer->d_inode->i_mutex);

	/* if there's an extension to a partial page at the end of the backing
	 * file, we need to discard the partial page so that we pick up new
	 * data after it */
	if (oi_size & ~PAGE_MASK && ni_size > oi_size) {
		_debug("discard tail %llx", oi_size);
		newattrs.ia_valid = ATTR_SIZE;
		newattrs.ia_size = oi_size & PAGE_MASK;
		ret = notify_change(object->backer, &newattrs);
		if (ret < 0)
			goto truncate_failed;
	}

	newattrs.ia_valid = ATTR_SIZE;
	newattrs.ia_size = ni_size;
	ret = notify_change(object->backer, &newattrs);

truncate_failed:
	mutex_unlock(&object->backer->d_inode->i_mutex);
	cachefiles_end_secure(cache, saved_cred);

	if (ret == -EIO) {
		fscache_set_store_limit(&object->fscache, 0);
		cachefiles_io_error_obj(object, "Size set failed");
		ret = -ENOBUFS;
	}

	_leave(" = %d", ret);
	return ret;
}

/*
 * Invalidate an object
 */
static void cachefiles_invalidate_object(struct fscache_operation *op)
{
	struct cachefiles_object *object;
	struct cachefiles_cache *cache;
	const struct cred *saved_cred;
	struct path path;
	uint64_t ni_size;
	int ret;

	object = container_of(op->object, struct cachefiles_object, fscache);
	cache = container_of(object->fscache.cache,
			     struct cachefiles_cache, cache);

	op->object->cookie->def->get_attr(op->object->cookie->netfs_data,
					  &ni_size);

	_enter("{OBJ%x},[%llu]",
	       op->object->debug_id, (unsigned long long)ni_size);

	if (object->backer) {
		ASSERT(S_ISREG(object->backer->d_inode->i_mode));

		fscache_set_store_limit(&object->fscache, ni_size);

		path.dentry = object->backer;
		path.mnt = cache->mnt;

		cachefiles_begin_secure(cache, &saved_cred);
		ret = vfs_truncate(&path, 0);
		if (ret == 0)
			ret = vfs_truncate(&path, ni_size);
		cachefiles_end_secure(cache, saved_cred);

		if (ret != 0) {
			fscache_set_store_limit(&object->fscache, 0);
			if (ret == -EIO)
				cachefiles_io_error_obj(object,
							"Invalidate failed");
		}
	}

	fscache_op_complete(op, true);
	_leave("");
}

/*
 * dissociate a cache from all the pages it was backing
 */
static void cachefiles_dissociate_pages(struct fscache_cache *cache)
{
	_enter("");
}

const struct fscache_cache_ops cachefiles_cache_ops = {
	.name			= "cachefiles",
	.alloc_object		= cachefiles_alloc_object,
	.lookup_object		= cachefiles_lookup_object,
	.lookup_complete	= cachefiles_lookup_complete,
	.grab_object		= cachefiles_grab_object,
	.update_object		= cachefiles_update_object,
	.invalidate_object	= cachefiles_invalidate_object,
	.drop_object		= cachefiles_drop_object,
	.put_object		= cachefiles_put_object,
	.sync_cache		= cachefiles_sync_cache,
	.attr_changed		= cachefiles_attr_changed,
	.read_or_alloc_page	= cachefiles_read_or_alloc_page,
	.read_or_alloc_pages	= cachefiles_read_or_alloc_pages,
	.allocate_page		= cachefiles_allocate_page,
	.allocate_pages		= cachefiles_allocate_pages,
	.write_page		= cachefiles_write_page,
	.uncache_page		= cachefiles_uncache_page,
	.dissociate_pages	= cachefiles_dissociate_pages,
};
Commit	Line	Data
9ae326a6 DH	1	/* FS-Cache interface to CacheFiles
	2	*
	3	* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells ([email protected])
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
	10	*/
	11
5a0e3ad6	12	#include <linux/slab.h>
9ae326a6	13	#include <linux/mount.h>
9ae326a6 DH	14	#include "internal.h"
	15
	16	#define list_to_page(head) (list_entry((head)->prev, struct page, lru))
	17
	18	struct cachefiles_lookup_data {
	19	struct cachefiles_xattr auxdata; / auxiliary data */
	20	char key; / key path */
	21	};
	22
	23	static int cachefiles_attr_changed(struct fscache_object *_object);
	24
	25	/*
	26	* allocate an object record for a cookie lookup and prepare the lookup data
	27	*/
	28	static struct fscache_object *cachefiles_alloc_object(
	29	struct fscache_cache *_cache,
	30	struct fscache_cookie *cookie)
	31	{
	32	struct cachefiles_lookup_data *lookup_data;
	33	struct cachefiles_object *object;
	34	struct cachefiles_cache *cache;
	35	struct cachefiles_xattr *auxdata;
	36	unsigned keylen, auxlen;
	37	void *buffer;
	38	char *key;
	39
	40	cache = container_of(_cache, struct cachefiles_cache, cache);
	41
	42	_enter("{%s},%p,", cache->cache.identifier, cookie);
	43
5f4f9f4a	44	lookup_data = kmalloc(sizeof(*lookup_data), cachefiles_gfp);
9ae326a6 DH	45	if (!lookup_data)
	46	goto nomem_lookup_data;
	47
	48	/* create a new object record and a temporary leaf image */
5f4f9f4a	49	object = kmem_cache_alloc(cachefiles_object_jar, cachefiles_gfp);
9ae326a6 DH	50	if (!object)
	51	goto nomem_object;
	52
	53	ASSERTCMP(object->backer, ==, NULL);
	54
	55	BUG_ON(test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags));
	56	atomic_set(&object->usage, 1);
	57
	58	fscache_object_init(&object->fscache, cookie, &cache->cache);
	59
	60	object->type = cookie->def->type;
	61
	62	/* get hold of the raw key
	63	* - stick the length on the front and leave space on the back for the
	64	* encoder
	65	*/
5f4f9f4a	66	buffer = kmalloc((2 + 512) + 3, cachefiles_gfp);
9ae326a6 DH	67	if (!buffer)
	68	goto nomem_buffer;
	69
	70	keylen = cookie->def->get_key(cookie->netfs_data, buffer + 2, 512);
	71	ASSERTCMP(keylen, <, 512);
	72
	73	(uint16_t )buffer = keylen;
	74	((char *)buffer)[keylen + 2] = 0;
	75	((char *)buffer)[keylen + 3] = 0;
	76	((char *)buffer)[keylen + 4] = 0;
	77
	78	/* turn the raw key into something that can work with as a filename */
	79	key = cachefiles_cook_key(buffer, keylen + 2, object->type);
	80	if (!key)
	81	goto nomem_key;
	82
	83	/* get hold of the auxiliary data and prepend the object type */
	84	auxdata = buffer;
	85	auxlen = 0;
	86	if (cookie->def->get_aux) {
	87	auxlen = cookie->def->get_aux(cookie->netfs_data,
	88	auxdata->data, 511);
	89	ASSERTCMP(auxlen, <, 511);
	90	}
	91
	92	auxdata->len = auxlen + 1;
	93	auxdata->type = cookie->def->type;
	94
	95	lookup_data->auxdata = auxdata;
	96	lookup_data->key = key;
	97	object->lookup_data = lookup_data;
	98
	99	_leave(" = %p [%p]", &object->fscache, lookup_data);
	100	return &object->fscache;
	101
	102	nomem_key:
	103	kfree(buffer);
	104	nomem_buffer:
	105	BUG_ON(test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags));
	106	kmem_cache_free(cachefiles_object_jar, object);
	107	fscache_object_destroyed(&cache->cache);
	108	nomem_object:
	109	kfree(lookup_data);
	110	nomem_lookup_data:
	111	_leave(" = -ENOMEM");
	112	return ERR_PTR(-ENOMEM);
	113	}
	114
	115	/*
	116	* attempt to look up the nominated node in this cache
fee096de	117	* - return -ETIMEDOUT to be scheduled again
9ae326a6	118	*/
fee096de	119	static int cachefiles_lookup_object(struct fscache_object *_object)
9ae326a6 DH	120	{
	121	struct cachefiles_lookup_data *lookup_data;
	122	struct cachefiles_object parent, object;
	123	struct cachefiles_cache *cache;
	124	const struct cred *saved_cred;
	125	int ret;
	126
	127	_enter("{OBJ%x}", _object->debug_id);
	128
	129	cache = container_of(_object->cache, struct cachefiles_cache, cache);
	130	parent = container_of(_object->parent,
	131	struct cachefiles_object, fscache);
	132	object = container_of(_object, struct cachefiles_object, fscache);
	133	lookup_data = object->lookup_data;
	134
	135	ASSERTCMP(lookup_data, !=, NULL);
	136
	137	/* look up the key, creating any missing bits */
	138	cachefiles_begin_secure(cache, &saved_cred);
	139	ret = cachefiles_walk_to_object(parent, object,
	140	lookup_data->key,
	141	lookup_data->auxdata);
	142	cachefiles_end_secure(cache, saved_cred);
	143
	144	/* polish off by setting the attributes of non-index files */
	145	if (ret == 0 &&
	146	object->fscache.cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX)
	147	cachefiles_attr_changed(&object->fscache);
	148
fee096de	149	if (ret < 0 && ret != -ETIMEDOUT) {
14e69647 DH	150	if (ret != -ENOBUFS)
	151	printk(KERN_WARNING
	152	"CacheFiles: Lookup failed error %d\n", ret);
9ae326a6 DH	153	fscache_object_lookup_error(&object->fscache);
	154	}
	155
	156	_leave(" [%d]", ret);
fee096de	157	return ret;
9ae326a6 DH	158	}
	159
	160	/*
	161	* indication of lookup completion
	162	*/
	163	static void cachefiles_lookup_complete(struct fscache_object *_object)
	164	{
	165	struct cachefiles_object *object;
	166
	167	object = container_of(_object, struct cachefiles_object, fscache);
	168
	169	_enter("{OBJ%x,%p}", object->fscache.debug_id, object->lookup_data);
	170
	171	if (object->lookup_data) {
	172	kfree(object->lookup_data->key);
	173	kfree(object->lookup_data->auxdata);
	174	kfree(object->lookup_data);
	175	object->lookup_data = NULL;
	176	}
	177	}
	178
	179	/*
	180	* increment the usage count on an inode object (may fail if unmounting)
	181	*/
	182	static
	183	struct fscache_object cachefiles_grab_object(struct fscache_object _object)
	184	{
	185	struct cachefiles_object *object =
	186	container_of(_object, struct cachefiles_object, fscache);
	187
	188	_enter("{OBJ%x,%d}", _object->debug_id, atomic_read(&object->usage));
	189
	190	#ifdef CACHEFILES_DEBUG_SLAB
	191	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
	192	#endif
	193
	194	atomic_inc(&object->usage);
	195	return &object->fscache;
	196	}
	197
	198	/*
25985edc	199	* update the auxiliary data for an object object on disk
9ae326a6 DH	200	*/
	201	static void cachefiles_update_object(struct fscache_object *_object)
	202	{
	203	struct cachefiles_object *object;
	204	struct cachefiles_xattr *auxdata;
	205	struct cachefiles_cache *cache;
	206	struct fscache_cookie *cookie;
	207	const struct cred *saved_cred;
	208	unsigned auxlen;
	209
	210	_enter("{OBJ%x}", _object->debug_id);
	211
	212	object = container_of(_object, struct cachefiles_object, fscache);
	213	cache = container_of(object->fscache.cache, struct cachefiles_cache,
	214	cache);
	215	cookie = object->fscache.cookie;
	216
	217	if (!cookie->def->get_aux) {
	218	_leave(" [no aux]");
	219	return;
	220	}
	221
5f4f9f4a	222	auxdata = kmalloc(2 + 512 + 3, cachefiles_gfp);
9ae326a6 DH	223	if (!auxdata) {
	224	_leave(" [nomem]");
	225	return;
	226	}
	227
	228	auxlen = cookie->def->get_aux(cookie->netfs_data, auxdata->data, 511);
	229	ASSERTCMP(auxlen, <, 511);
	230
	231	auxdata->len = auxlen + 1;
	232	auxdata->type = cookie->def->type;
	233
	234	cachefiles_begin_secure(cache, &saved_cred);
	235	cachefiles_update_object_xattr(object, auxdata);
	236	cachefiles_end_secure(cache, saved_cred);
	237	kfree(auxdata);
	238	_leave("");
	239	}
	240
	241	/*
	242	* discard the resources pinned by an object and effect retirement if
	243	* requested
	244	*/
	245	static void cachefiles_drop_object(struct fscache_object *_object)
	246	{
	247	struct cachefiles_object *object;
	248	struct cachefiles_cache *cache;
	249	const struct cred *saved_cred;
	250
	251	ASSERT(_object);
	252
	253	object = container_of(_object, struct cachefiles_object, fscache);
	254
	255	_enter("{OBJ%x,%d}",
	256	object->fscache.debug_id, atomic_read(&object->usage));
	257
	258	cache = container_of(object->fscache.cache,
	259	struct cachefiles_cache, cache);
	260
	261	#ifdef CACHEFILES_DEBUG_SLAB
	262	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
	263	#endif
	264
	265	/* delete retired objects */
	266	if (object->fscache.state == FSCACHE_OBJECT_RECYCLING &&
	267	_object != cache->cache.fsdef
	268	) {
	269	_debug("- retire object OBJ%x", object->fscache.debug_id);
	270	cachefiles_begin_secure(cache, &saved_cred);
	271	cachefiles_delete_object(cache, object);
	272	cachefiles_end_secure(cache, saved_cred);
	273	}
	274
	275	/* close the filesystem stuff attached to the object */
	276	if (object->backer != object->dentry)
	277	dput(object->backer);
	278	object->backer = NULL;
	279
	280	/* note that the object is now inactive */
	281	if (test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
	282	write_lock(&cache->active_lock);
	283	if (!test_and_clear_bit(CACHEFILES_OBJECT_ACTIVE,
	284	&object->flags))
	285	BUG();
	286	rb_erase(&object->active_node, &cache->active_nodes);
287	wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
288	write_unlock(&cache->active_lock);
289	}
290
291	dput(object->dentry);
292	object->dentry = NULL;
293
294	_leave("");
295	}
296
297	/*
298	* dispose of a reference to an object
299	*/
300	static void cachefiles_put_object(struct fscache_object *_object)
301	{
302	struct cachefiles_object *object;
303	struct fscache_cache *cache;
304
305	ASSERT(_object);
306
307	object = container_of(_object, struct cachefiles_object, fscache);
308
309	_enter("{OBJ%x,%d}",
310	object->fscache.debug_id, atomic_read(&object->usage));
311
312	#ifdef CACHEFILES_DEBUG_SLAB
313	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
314	#endif
315
316	ASSERTIFCMP(object->fscache.parent,
317	object->fscache.parent->n_children, >, 0);
318
319	if (atomic_dec_and_test(&object->usage)) {
320	_debug("- kill object OBJ%x", object->fscache.debug_id);
321
322	ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags));
323	ASSERTCMP(object->fscache.parent, ==, NULL);
324	ASSERTCMP(object->backer, ==, NULL);
325	ASSERTCMP(object->dentry, ==, NULL);
326	ASSERTCMP(object->fscache.n_ops, ==, 0);
327	ASSERTCMP(object->fscache.n_children, ==, 0);
328
329	if (object->lookup_data) {
330	kfree(object->lookup_data->key);
331	kfree(object->lookup_data->auxdata);
332	kfree(object->lookup_data);
333	object->lookup_data = NULL;
334	}
335
336	cache = object->fscache.cache;
4fbf4291	337	fscache_object_destroy(&object->fscache);
9ae326a6 DH	338	kmem_cache_free(cachefiles_object_jar, object);
	339	fscache_object_destroyed(cache);
	340	}
	341
	342	_leave("");
	343	}
	344
	345	/*
	346	* sync a cache
	347	*/
	348	static void cachefiles_sync_cache(struct fscache_cache *_cache)
	349	{
	350	struct cachefiles_cache *cache;
	351	const struct cred *saved_cred;
	352	int ret;
	353
	354	_enter("%p", _cache);
	355
	356	cache = container_of(_cache, struct cachefiles_cache, cache);
	357
	358	/* make sure all pages pinned by operations on behalf of the netfs are
	359	* written to disc */
	360	cachefiles_begin_secure(cache, &saved_cred);
5af7926f	361	down_read(&cache->mnt->mnt_sb->s_umount);
60b0680f	362	ret = sync_filesystem(cache->mnt->mnt_sb);
5af7926f	363	up_read(&cache->mnt->mnt_sb->s_umount);
9ae326a6 DH	364	cachefiles_end_secure(cache, saved_cred);
	365
	366	if (ret == -EIO)
	367	cachefiles_io_error(cache,
	368	"Attempt to sync backing fs superblock"
	369	" returned error %d",
	370	ret);
	371	}
	372
	373	/*
	374	* notification the attributes on an object have changed
	375	* - called with reads/writes excluded by FS-Cache
	376	*/
	377	static int cachefiles_attr_changed(struct fscache_object *_object)
	378	{
	379	struct cachefiles_object *object;
	380	struct cachefiles_cache *cache;
	381	const struct cred *saved_cred;
	382	struct iattr newattrs;
	383	uint64_t ni_size;
	384	loff_t oi_size;
	385	int ret;
	386
	387	_object->cookie->def->get_attr(_object->cookie->netfs_data, &ni_size);
	388
	389	_enter("{OBJ%x},[%llu]",
	390	_object->debug_id, (unsigned long long) ni_size);
	391
	392	object = container_of(_object, struct cachefiles_object, fscache);
	393	cache = container_of(object->fscache.cache,
	394	struct cachefiles_cache, cache);
	395
	396	if (ni_size == object->i_size)
	397	return 0;
	398
	399	if (!object->backer)
	400	return -ENOBUFS;
	401
	402	ASSERT(S_ISREG(object->backer->d_inode->i_mode));
	403
	404	fscache_set_store_limit(&object->fscache, ni_size);
	405
	406	oi_size = i_size_read(object->backer->d_inode);
	407	if (oi_size == ni_size)
	408	return 0;
	409
9ae326a6 DH	410	cachefiles_begin_secure(cache, &saved_cred);
9ae326a6 DH	411	mutex_lock(&object->backer->d_inode->i_mutex);
a17754fb DH	412
	413	/* if there's an extension to a partial page at the end of the backing
	414	* file, we need to discard the partial page so that we pick up new
	415	* data after it */
	416	if (oi_size & ~PAGE_MASK && ni_size > oi_size) {
	417	_debug("discard tail %llx", oi_size);
	418	newattrs.ia_valid = ATTR_SIZE;
	419	newattrs.ia_size = oi_size & PAGE_MASK;
	420	ret = notify_change(object->backer, &newattrs);
	421	if (ret < 0)
	422	goto truncate_failed;
	423	}
	424
	425	newattrs.ia_valid = ATTR_SIZE;
	426	newattrs.ia_size = ni_size;
9ae326a6	427	ret = notify_change(object->backer, &newattrs);
a17754fb DH	428
a17754fb DH	429	truncate_failed:
9ae326a6 DH	430	mutex_unlock(&object->backer->d_inode->i_mutex);
	431	cachefiles_end_secure(cache, saved_cred);
	432
	433	if (ret == -EIO) {
	434	fscache_set_store_limit(&object->fscache, 0);
	435	cachefiles_io_error_obj(object, "Size set failed");
	436	ret = -ENOBUFS;
	437	}
	438
	439	_leave(" = %d", ret);
	440	return ret;
	441	}
	442
9dc8d9bf DH	443	/*
	444	* Invalidate an object
	445	*/
	446	static void cachefiles_invalidate_object(struct fscache_operation *op)
	447	{
	448	struct cachefiles_object *object;
	449	struct cachefiles_cache *cache;
	450	const struct cred *saved_cred;
	451	struct path path;
	452	uint64_t ni_size;
	453	int ret;
	454
	455	object = container_of(op->object, struct cachefiles_object, fscache);
	456	cache = container_of(object->fscache.cache,
	457	struct cachefiles_cache, cache);
	458
	459	op->object->cookie->def->get_attr(op->object->cookie->netfs_data,
	460	&ni_size);
	461
	462	_enter("{OBJ%x},[%llu]",
	463	op->object->debug_id, (unsigned long long)ni_size);
	464
	465	if (object->backer) {
	466	ASSERT(S_ISREG(object->backer->d_inode->i_mode));
	467
	468	fscache_set_store_limit(&object->fscache, ni_size);
	469
	470	path.dentry = object->backer;
	471	path.mnt = cache->mnt;
	472
	473	cachefiles_begin_secure(cache, &saved_cred);
	474	ret = vfs_truncate(&path, 0);
	475	if (ret == 0)
	476	ret = vfs_truncate(&path, ni_size);
	477	cachefiles_end_secure(cache, saved_cred);
	478
	479	if (ret != 0) {
	480	fscache_set_store_limit(&object->fscache, 0);
	481	if (ret == -EIO)
	482	cachefiles_io_error_obj(object,
	483	"Invalidate failed");
	484	}
	485	}
	486
1f372dff	487	fscache_op_complete(op, true);
9dc8d9bf DH	488	_leave("");
	489	}
	490
9ae326a6 DH	491	/*
	492	* dissociate a cache from all the pages it was backing
	493	*/
	494	static void cachefiles_dissociate_pages(struct fscache_cache *cache)
	495	{
	496	_enter("");
	497	}
	498
	499	const struct fscache_cache_ops cachefiles_cache_ops = {
	500	.name = "cachefiles",
	501	.alloc_object = cachefiles_alloc_object,
	502	.lookup_object = cachefiles_lookup_object,
	503	.lookup_complete = cachefiles_lookup_complete,
	504	.grab_object = cachefiles_grab_object,
	505	.update_object = cachefiles_update_object,
9dc8d9bf	506	.invalidate_object = cachefiles_invalidate_object,
9ae326a6 DH	507	.drop_object = cachefiles_drop_object,
	508	.put_object = cachefiles_put_object,
	509	.sync_cache = cachefiles_sync_cache,
	510	.attr_changed = cachefiles_attr_changed,
	511	.read_or_alloc_page = cachefiles_read_or_alloc_page,
	512	.read_or_alloc_pages = cachefiles_read_or_alloc_pages,
	513	.allocate_page = cachefiles_allocate_page,
	514	.allocate_pages = cachefiles_allocate_pages,
	515	.write_page = cachefiles_write_page,
	516	.uncache_page = cachefiles_uncache_page,
	517	.dissociate_pages = cachefiles_dissociate_pages,
	518	};