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 <linux/slab.h>
20#include "internal.h"
21
22static 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 */
29int 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		pr_err("Can't set xattr on %*.*s [%lu] (err %d)\n",
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		pr_err("Can't read xattr on %*.*s [%lu] (err %d)\n",
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
83error:
84	_leave(" = %d", ret);
85	return ret;
86
87bad_type_length:
88	pr_err("Cache object %lu type xattr length incorrect\n",
89	       dentry->d_inode->i_ino);
90	ret = -EIO;
91	goto error;
92
93bad_type:
94	xtype[2] = 0;
95	pr_err("Cache object %*.*s [%lu] type %s not %s\n",
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 */
106int cachefiles_set_object_xattr(struct cachefiles_object *object,
107				struct cachefiles_xattr *auxdata)
108{
109	struct dentry *dentry = object->dentry;
110	int ret;
111
112	ASSERT(dentry);
113
114	_enter("%p,#%d", object, auxdata->len);
115
116	/* attempt to install the cache metadata directly */
117	_debug("SET #%u", 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 */
134int 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(dentry);
141
142	_enter("%p,#%d", object, auxdata->len);
143
144	/* attempt to install the cache metadata directly */
145	_debug("SET #%u", auxdata->len);
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
159/*
160 * check the consistency between the backing cache and the FS-Cache cookie
161 */
162int cachefiles_check_auxdata(struct cachefiles_object *object)
163{
164	struct cachefiles_xattr *auxbuf;
165	enum fscache_checkaux validity;
166	struct dentry *dentry = object->dentry;
167	ssize_t xlen;
168	int ret;
169
170	ASSERT(dentry);
171	ASSERT(dentry->d_inode);
172	ASSERT(object->fscache.cookie->def->check_aux);
173
174	auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
175	if (!auxbuf)
176		return -ENOMEM;
177
178	xlen = vfs_getxattr(dentry, cachefiles_xattr_cache,
179			    &auxbuf->type, 512 + 1);
180	ret = -ESTALE;
181	if (xlen < 1 ||
182	    auxbuf->type != object->fscache.cookie->def->type)
183		goto error;
184
185	xlen--;
186	validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen);
187	if (validity != FSCACHE_CHECKAUX_OKAY)
188		goto error;
189
190	ret = 0;
191error:
192	kfree(auxbuf);
193	return ret;
194}
195
196/*
197 * check the state xattr on a cache file
198 * - return -ESTALE if the object should be deleted
199 */
200int cachefiles_check_object_xattr(struct cachefiles_object *object,
201				  struct cachefiles_xattr *auxdata)
202{
203	struct cachefiles_xattr *auxbuf;
204	struct dentry *dentry = object->dentry;
205	int ret;
206
207	_enter("%p,#%d", object, auxdata->len);
208
209	ASSERT(dentry);
210	ASSERT(dentry->d_inode);
211
212	auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
213	if (!auxbuf) {
214		_leave(" = -ENOMEM");
215		return -ENOMEM;
216	}
217
218	/* read the current type label */
219	ret = vfs_getxattr(dentry, cachefiles_xattr_cache,
220			   &auxbuf->type, 512 + 1);
221	if (ret < 0) {
222		if (ret == -ENODATA)
223			goto stale; /* no attribute - power went off
224				     * mid-cull? */
225
226		if (ret == -ERANGE)
227			goto bad_type_length;
228
229		cachefiles_io_error_obj(object,
230					"Can't read xattr on %lu (err %d)",
231					dentry->d_inode->i_ino, -ret);
232		goto error;
233	}
234
235	/* check the on-disk object */
236	if (ret < 1)
237		goto bad_type_length;
238
239	if (auxbuf->type != auxdata->type)
240		goto stale;
241
242	auxbuf->len = ret;
243
244	/* consult the netfs */
245	if (object->fscache.cookie->def->check_aux) {
246		enum fscache_checkaux result;
247		unsigned int dlen;
248
249		dlen = auxbuf->len - 1;
250
251		_debug("checkaux %s #%u",
252		       object->fscache.cookie->def->name, dlen);
253
254		result = fscache_check_aux(&object->fscache,
255					   &auxbuf->data, dlen);
256
257		switch (result) {
258			/* entry okay as is */
259		case FSCACHE_CHECKAUX_OKAY:
260			goto okay;
261
262			/* entry requires update */
263		case FSCACHE_CHECKAUX_NEEDS_UPDATE:
264			break;
265
266			/* entry requires deletion */
267		case FSCACHE_CHECKAUX_OBSOLETE:
268			goto stale;
269
270		default:
271			BUG();
272		}
273
274		/* update the current label */
275		ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
276				   &auxdata->type, auxdata->len,
277				   XATTR_REPLACE);
278		if (ret < 0) {
279			cachefiles_io_error_obj(object,
280						"Can't update xattr on %lu"
281						" (error %d)",
282						dentry->d_inode->i_ino, -ret);
283			goto error;
284		}
285	}
286
287okay:
288	ret = 0;
289
290error:
291	kfree(auxbuf);
292	_leave(" = %d", ret);
293	return ret;
294
295bad_type_length:
296	pr_err("Cache object %lu xattr length incorrect\n",
297	       dentry->d_inode->i_ino);
298	ret = -EIO;
299	goto error;
300
301stale:
302	ret = -ESTALE;
303	goto error;
304}
305
306/*
307 * remove the object's xattr to mark it stale
308 */
309int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
310				   struct dentry *dentry)
311{
312	int ret;
313
314	ret = vfs_removexattr(dentry, cachefiles_xattr_cache);
315	if (ret < 0) {
316		if (ret == -ENOENT || ret == -ENODATA)
317			ret = 0;
318		else if (ret != -ENOMEM)
319			cachefiles_io_error(cache,
320					    "Can't remove xattr from %lu"
321					    " (error %d)",
322					    dentry->d_inode->i_ino, -ret);
323	}
324
325	_leave(" = %d", ret);
326	return ret;
327}
328