[linux-block.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 "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(object->fscache.cookie);
	ASSERT(dentry);

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

	/* attempt to install the cache metadata directly */
	_debug("SET %s #%u", object->fscache.cookie->def->name, 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(object->fscache.cookie);
	ASSERT(dentry);

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

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