[deliverable/linux.git] / fs / cachefiles / xattr.c

/* CacheFiles extended attribute management
 *
 * Copyright (C) 2007 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 Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/fsnotify.h>
#include <linux/quotaops.h>
#include <linux/xattr.h>
#include <linux/slab.h>
#include "internal.h"

static const char cachefiles_xattr_cache[] =
	XATTR_USER_PREFIX "CacheFiles.cache";

/*
 * check the type label on an object
 * - done using xattrs
 */
int cachefiles_check_object_type(struct cachefiles_object *object)
{
	struct dentry *dentry = object->dentry;
	char type[3], xtype[3];
	int ret;

	ASSERT(dentry);
	ASSERT(dentry->d_inode);

	if (!object->fscache.cookie)
		strcpy(type, "C3");
	else
		snprintf(type, 3, "%02x", object->fscache.cookie->def->type);

	_enter("%p{%s}", object, type);

	/* attempt to install a type label directly */
	ret = vfs_setxattr(dentry, cachefiles_xattr_cache, type, 2,
			   XATTR_CREATE);
	if (ret == 0) {
		_debug("SET"); /* we succeeded */
		goto error;
	}

	if (ret != -EEXIST) {
		kerror("Can't set xattr on %*.*s [%lu] (err %d)",
		       dentry->d_name.len, dentry->d_name.len,
		       dentry->d_name.name, dentry->d_inode->i_ino,
		       -ret);
		goto error;
	}

	/* read the current type label */
	ret = vfs_getxattr(dentry, cachefiles_xattr_cache, xtype, 3);
	if (ret < 0) {
		if (ret == -ERANGE)
			goto bad_type_length;

		kerror("Can't read xattr on %*.*s [%lu] (err %d)",
		       dentry->d_name.len, dentry->d_name.len,
		       dentry->d_name.name, dentry->d_inode->i_ino,
		       -ret);
		goto error;
	}

	/* check the type is what we're expecting */
	if (ret != 2)
		goto bad_type_length;

	if (xtype[0] != type[0] || xtype[1] != type[1])
		goto bad_type;

	ret = 0;

error:
	_leave(" = %d", ret);
	return ret;

bad_type_length:
	kerror("Cache object %lu type xattr length incorrect",
	       dentry->d_inode->i_ino);
	ret = -EIO;
	goto error;

bad_type:
	xtype[2] = 0;
	kerror("Cache object %*.*s [%lu] type %s not %s",
	       dentry->d_name.len, dentry->d_name.len,
	       dentry->d_name.name, dentry->d_inode->i_ino,
	       xtype, type);
	ret = -EIO;
	goto error;
}

/*
 * set the state xattr on a cache file
 */
int cachefiles_set_object_xattr(struct cachefiles_object *object,
				struct cachefiles_xattr *auxdata)
{
	struct dentry *dentry = object->dentry;
	int ret;

	ASSERT(dentry);

	_enter("%p,#%d", object, auxdata->len);

	/* attempt to install the cache metadata directly */
	_debug("SET #%u", auxdata->len);

	ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
			   &auxdata->type, auxdata->len,
			   XATTR_CREATE);
	if (ret < 0 && ret != -ENOMEM)
		cachefiles_io_error_obj(
			object,
			"Failed to set xattr with error %d", ret);

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

/*
 * update the state xattr on a cache file
 */
int cachefiles_update_object_xattr(struct cachefiles_object *object,
				   struct cachefiles_xattr *auxdata)
{
	struct dentry *dentry = object->dentry;
	int ret;

	ASSERT(dentry);

	_enter("%p,#%d", object, auxdata->len);

	/* attempt to install the cache metadata directly */
	_debug("SET #%u", auxdata->len);

	ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
			   &auxdata->type, auxdata->len,
			   XATTR_REPLACE);
	if (ret < 0 && ret != -ENOMEM)
		cachefiles_io_error_obj(
			object,
			"Failed to update xattr with error %d", ret);

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

/*
 * check the consistency between the backing cache and the FS-Cache cookie
 */
int cachefiles_check_auxdata(struct cachefiles_object *object)
{
	struct cachefiles_xattr *auxbuf;
	struct dentry *dentry = object->dentry;
	unsigned int dlen;
	int ret;

	ASSERT(dentry);
	ASSERT(dentry->d_inode);
	ASSERT(object->fscache.cookie->def->check_aux);

	auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
	if (!auxbuf)
		return -ENOMEM;

	auxbuf->len = vfs_getxattr(dentry, cachefiles_xattr_cache,
				   &auxbuf->type, 512 + 1);
	if (auxbuf->len < 1)
		return -ESTALE;

	if (auxbuf->type != object->fscache.cookie->def->type)
		return -ESTALE;

	dlen = auxbuf->len - 1;
	ret = fscache_check_aux(&object->fscache, &auxbuf->data, dlen);

	kfree(auxbuf);
	if (ret != FSCACHE_CHECKAUX_OKAY)
		return -ESTALE;

	return 0;
}

/*
 * check the state xattr on a cache file
 * - return -ESTALE if the object should be deleted
 */
int cachefiles_check_object_xattr(struct cachefiles_object *object,
				  struct cachefiles_xattr *auxdata)
{
	struct cachefiles_xattr *auxbuf;
	struct dentry *dentry = object->dentry;
	int ret;

	_enter("%p,#%d", object, auxdata->len);

	ASSERT(dentry);
	ASSERT(dentry->d_inode);

	auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
	if (!auxbuf) {
		_leave(" = -ENOMEM");
		return -ENOMEM;
	}

	/* read the current type label */
	ret = vfs_getxattr(dentry, cachefiles_xattr_cache,
			   &auxbuf->type, 512 + 1);
	if (ret < 0) {
		if (ret == -ENODATA)
			goto stale; /* no attribute - power went off
				     * mid-cull? */

		if (ret == -ERANGE)
			goto bad_type_length;

		cachefiles_io_error_obj(object,
					"Can't read xattr on %lu (err %d)",
					dentry->d_inode->i_ino, -ret);
		goto error;
	}

	/* check the on-disk object */
	if (ret < 1)
		goto bad_type_length;

	if (auxbuf->type != auxdata->type)
		goto stale;

	auxbuf->len = ret;

	/* consult the netfs */
	if (object->fscache.cookie->def->check_aux) {
		enum fscache_checkaux result;
		unsigned int dlen;

		dlen = auxbuf->len - 1;

		_debug("checkaux %s #%u",
		       object->fscache.cookie->def->name, dlen);

		result = fscache_check_aux(&object->fscache,
					   &auxbuf->data, dlen);

		switch (result) {
			/* entry okay as is */
		case FSCACHE_CHECKAUX_OKAY:
			goto okay;

			/* entry requires update */
		case FSCACHE_CHECKAUX_NEEDS_UPDATE:
			break;

			/* entry requires deletion */
		case FSCACHE_CHECKAUX_OBSOLETE:
			goto stale;

		default:
			BUG();
		}

		/* update the current label */
		ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
				   &auxdata->type, auxdata->len,
				   XATTR_REPLACE);
		if (ret < 0) {
			cachefiles_io_error_obj(object,
						"Can't update xattr on %lu"
						" (error %d)",
						dentry->d_inode->i_ino, -ret);
			goto error;
		}
	}

okay:
	ret = 0;

error:
	kfree(auxbuf);
	_leave(" = %d", ret);
	return ret;

bad_type_length:
	kerror("Cache object %lu xattr length incorrect",
	       dentry->d_inode->i_ino);
	ret = -EIO;
	goto error;

stale:
	ret = -ESTALE;
	goto error;
}

/*
 * remove the object's xattr to mark it stale
 */
int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
				   struct dentry *dentry)
{
	int ret;

	ret = vfs_removexattr(dentry, cachefiles_xattr_cache);
	if (ret < 0) {
		if (ret == -ENOENT || ret == -ENODATA)
			ret = 0;
		else if (ret != -ENOMEM)
			cachefiles_io_error(cache,
					    "Can't remove xattr from %lu"
					    " (error %d)",
					    dentry->d_inode->i_ino, -ret);
	}

	_leave(" = %d", ret);
	return ret;
}
Commit	Line	Data
9ae326a6 DH	1	/* CacheFiles extended attribute management
	2	*
	3	* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
	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 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
	12	#include <linux/module.h>
	13	#include <linux/sched.h>
	14	#include <linux/file.h>
	15	#include <linux/fs.h>
	16	#include <linux/fsnotify.h>
	17	#include <linux/quotaops.h>
	18	#include <linux/xattr.h>
5a0e3ad6	19	#include <linux/slab.h>
9ae326a6 DH	20	#include "internal.h"
	21
	22	static const char cachefiles_xattr_cache[] =
	23	XATTR_USER_PREFIX "CacheFiles.cache";
	24
	25	/*
	26	* check the type label on an object
	27	* - done using xattrs
	28	*/
	29	int cachefiles_check_object_type(struct cachefiles_object *object)
	30	{
	31	struct dentry *dentry = object->dentry;
	32	char type[3], xtype[3];
	33	int ret;
	34
	35	ASSERT(dentry);
	36	ASSERT(dentry->d_inode);
	37
	38	if (!object->fscache.cookie)
	39	strcpy(type, "C3");
	40	else
	41	snprintf(type, 3, "%02x", object->fscache.cookie->def->type);
	42
	43	_enter("%p{%s}", object, type);
	44
	45	/* attempt to install a type label directly */
	46	ret = vfs_setxattr(dentry, cachefiles_xattr_cache, type, 2,
	47	XATTR_CREATE);
	48	if (ret == 0) {
	49	_debug("SET"); /* we succeeded */
	50	goto error;
	51	}
	52
	53	if (ret != -EEXIST) {
	54	kerror("Can't set xattr on %.s [%lu] (err %d)",
	55	dentry->d_name.len, dentry->d_name.len,
	56	dentry->d_name.name, dentry->d_inode->i_ino,
	57	-ret);
	58	goto error;
	59	}
	60
	61	/* read the current type label */
	62	ret = vfs_getxattr(dentry, cachefiles_xattr_cache, xtype, 3);
	63	if (ret < 0) {
	64	if (ret == -ERANGE)
	65	goto bad_type_length;
	66
	67	kerror("Can't read xattr on %.s [%lu] (err %d)",
	68	dentry->d_name.len, dentry->d_name.len,
	69	dentry->d_name.name, dentry->d_inode->i_ino,
	70	-ret);
	71	goto error;
	72	}
	73
	74	/* check the type is what we're expecting */
	75	if (ret != 2)
	76	goto bad_type_length;
	77
	78	if (xtype[0] != type[0] \|\| xtype[1] != type[1])
	79	goto bad_type;
	80
	81	ret = 0;
	82
	83	error:
84	_leave(" = %d", ret);
85	return ret;
86
87	bad_type_length:
88	kerror("Cache object %lu type xattr length incorrect",
89	dentry->d_inode->i_ino);
90	ret = -EIO;
91	goto error;
92
93	bad_type:
94	xtype[2] = 0;
95	kerror("Cache object %.s [%lu] type %s not %s",
96	dentry->d_name.len, dentry->d_name.len,
97	dentry->d_name.name, dentry->d_inode->i_ino,
98	xtype, type);
99	ret = -EIO;
100	goto error;
101	}
102
103	/*
104	* set the state xattr on a cache file
105	*/
106	int cachefiles_set_object_xattr(struct cachefiles_object *object,
107	struct cachefiles_xattr *auxdata)
108	{
109	struct dentry *dentry = object->dentry;
110	int ret;
111
9ae326a6 DH	112	ASSERT(dentry);
	113
	114	_enter("%p,#%d", object, auxdata->len);
	115
	116	/* attempt to install the cache metadata directly */
1362729b	117	_debug("SET #%u", auxdata->len);
9ae326a6 DH	118
	119	ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
	120	&auxdata->type, auxdata->len,
	121	XATTR_CREATE);
	122	if (ret < 0 && ret != -ENOMEM)
	123	cachefiles_io_error_obj(
	124	object,
	125	"Failed to set xattr with error %d", ret);
	126
	127	_leave(" = %d", ret);
	128	return ret;
	129	}
	130
	131	/*
	132	* update the state xattr on a cache file
	133	*/
	134	int cachefiles_update_object_xattr(struct cachefiles_object *object,
	135	struct cachefiles_xattr *auxdata)
	136	{
	137	struct dentry *dentry = object->dentry;
	138	int ret;
	139
9ae326a6 DH	140	ASSERT(dentry);
	141
	142	_enter("%p,#%d", object, auxdata->len);
	143
	144	/* attempt to install the cache metadata directly */
1362729b	145	_debug("SET #%u", auxdata->len);
9ae326a6 DH	146
	147	ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
	148	&auxdata->type, auxdata->len,
	149	XATTR_REPLACE);
	150	if (ret < 0 && ret != -ENOMEM)
	151	cachefiles_io_error_obj(
	152	object,
	153	"Failed to update xattr with error %d", ret);
	154
	155	_leave(" = %d", ret);
	156	return ret;
	157	}
	158
5002d7be DH	159	/*
	160	* check the consistency between the backing cache and the FS-Cache cookie
	161	*/
	162	int cachefiles_check_auxdata(struct cachefiles_object *object)
	163	{
	164	struct cachefiles_xattr *auxbuf;
	165	struct dentry *dentry = object->dentry;
	166	unsigned int dlen;
	167	int ret;
	168
	169	ASSERT(dentry);
	170	ASSERT(dentry->d_inode);
	171	ASSERT(object->fscache.cookie->def->check_aux);
	172
	173	auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
	174	if (!auxbuf)
	175	return -ENOMEM;
	176
	177	auxbuf->len = vfs_getxattr(dentry, cachefiles_xattr_cache,
	178	&auxbuf->type, 512 + 1);
	179	if (auxbuf->len < 1)
	180	return -ESTALE;
	181
	182	if (auxbuf->type != object->fscache.cookie->def->type)
	183	return -ESTALE;
	184
	185	dlen = auxbuf->len - 1;
	186	ret = fscache_check_aux(&object->fscache, &auxbuf->data, dlen);
	187
	188	kfree(auxbuf);
	189	if (ret != FSCACHE_CHECKAUX_OKAY)
	190	return -ESTALE;
	191
	192	return 0;
	193	}
	194
9ae326a6 DH	195	/*
	196	* check the state xattr on a cache file
	197	* - return -ESTALE if the object should be deleted
	198	*/
	199	int cachefiles_check_object_xattr(struct cachefiles_object *object,
	200	struct cachefiles_xattr *auxdata)
	201	{
	202	struct cachefiles_xattr *auxbuf;
	203	struct dentry *dentry = object->dentry;
	204	int ret;
	205
	206	_enter("%p,#%d", object, auxdata->len);
	207
	208	ASSERT(dentry);
	209	ASSERT(dentry->d_inode);
	210
5f4f9f4a	211	auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
9ae326a6 DH	212	if (!auxbuf) {
	213	_leave(" = -ENOMEM");
	214	return -ENOMEM;
	215	}
	216
	217	/* read the current type label */
	218	ret = vfs_getxattr(dentry, cachefiles_xattr_cache,
	219	&auxbuf->type, 512 + 1);
	220	if (ret < 0) {
	221	if (ret == -ENODATA)
	222	goto stale; /* no attribute - power went off
	223	* mid-cull? */
	224
	225	if (ret == -ERANGE)
	226	goto bad_type_length;
	227
	228	cachefiles_io_error_obj(object,
	229	"Can't read xattr on %lu (err %d)",
	230	dentry->d_inode->i_ino, -ret);
	231	goto error;
	232	}
	233
	234	/* check the on-disk object */
	235	if (ret < 1)
	236	goto bad_type_length;
	237
	238	if (auxbuf->type != auxdata->type)
	239	goto stale;
	240
	241	auxbuf->len = ret;
	242
	243	/* consult the netfs */
	244	if (object->fscache.cookie->def->check_aux) {
	245	enum fscache_checkaux result;
	246	unsigned int dlen;
	247
	248	dlen = auxbuf->len - 1;
	249
	250	_debug("checkaux %s #%u",
	251	object->fscache.cookie->def->name, dlen);
	252
	253	result = fscache_check_aux(&object->fscache,
	254	&auxbuf->data, dlen);
	255
	256	switch (result) {
	257	/* entry okay as is */
	258	case FSCACHE_CHECKAUX_OKAY:
	259	goto okay;
	260
	261	/* entry requires update */
	262	case FSCACHE_CHECKAUX_NEEDS_UPDATE:
	263	break;
	264
	265	/* entry requires deletion */
	266	case FSCACHE_CHECKAUX_OBSOLETE:
	267	goto stale;
	268
	269	default:
	270	BUG();
	271	}
	272
	273	/* update the current label */
	274	ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
	275	&auxdata->type, auxdata->len,
276	XATTR_REPLACE);
277	if (ret < 0) {
278	cachefiles_io_error_obj(object,
279	"Can't update xattr on %lu"
280	" (error %d)",
281	dentry->d_inode->i_ino, -ret);
282	goto error;
283	}
284	}
285
286	okay:
287	ret = 0;
288
289	error:
290	kfree(auxbuf);
291	_leave(" = %d", ret);
292	return ret;
293
294	bad_type_length:
295	kerror("Cache object %lu xattr length incorrect",
296	dentry->d_inode->i_ino);
297	ret = -EIO;
298	goto error;
299
300	stale:
301	ret = -ESTALE;
302	goto error;
303	}
304
305	/*
306	* remove the object's xattr to mark it stale
307	*/
308	int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
309	struct dentry *dentry)
310	{
311	int ret;
312
313	ret = vfs_removexattr(dentry, cachefiles_xattr_cache);
314	if (ret < 0) {
315	if (ret == -ENOENT \|\| ret == -ENODATA)
316	ret = 0;
317	else if (ret != -ENOMEM)
318	cachefiles_io_error(cache,
319	"Can't remove xattr from %lu"
320	" (error %d)",
321	dentry->d_inode->i_ino, -ret);
322	}
323
324	_leave(" = %d", ret);
325	return ret;
326	}