[linux-2.6-block.git] / fs / cachefiles / xattr.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* CacheFiles extended attribute management
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#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(d_backing_inode(dentry));

	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) {
		pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
		       dentry, d_backing_inode(dentry)->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;

		pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
		       dentry, d_backing_inode(dentry)->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:
	pr_err("Cache object %lu type xattr length incorrect\n",
	       d_backing_inode(dentry)->i_ino);
	ret = -EIO;
	goto error;

bad_type:
	xtype[2] = 0;
	pr_err("Cache object %pd [%lu] type %s not %s\n",
	       dentry, d_backing_inode(dentry)->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);

	clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
	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;

	if (!dentry)
		return -ESTALE;

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

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

	clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
	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;
	enum fscache_checkaux validity;
	struct dentry *dentry = object->dentry;
	ssize_t xlen;
	int ret;

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

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

	xlen = vfs_getxattr(dentry, cachefiles_xattr_cache,
			    &auxbuf->type, 512 + 1);
	ret = -ESTALE;
	if (xlen < 1 ||
	    auxbuf->type != object->fscache.cookie->def->type)
		goto error;

	xlen--;
	validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen,
				     i_size_read(d_backing_inode(dentry)));
	if (validity != FSCACHE_CHECKAUX_OKAY)
		goto error;

	ret = 0;
error:
	kfree(auxbuf);
	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(d_backing_inode(dentry));

	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)",
					d_backing_inode(dentry)->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,
					   i_size_read(d_backing_inode(dentry)));

		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)",
						d_backing_inode(dentry)->i_ino, -ret);
			goto error;
		}
	}

okay:
	ret = 0;

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

bad_type_length:
	pr_err("Cache object %lu xattr length incorrect\n",
	       d_backing_inode(dentry)->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)",
					    d_backing_inode(dentry)->i_ino, -ret);
	}

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