[mirror_ubuntu-hirsute-kernel.git] / fs / afs / xattr.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* Extended attribute handling for AFS.  We use xattrs to get and set metadata
 * instead of providing pioctl().
 *
 * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/xattr.h>
#include "internal.h"

static const char afs_xattr_list[] =
	"afs.acl\0"
	"afs.cell\0"
	"afs.fid\0"
	"afs.volume\0"
	"afs.yfs.acl\0"
	"afs.yfs.acl_inherited\0"
	"afs.yfs.acl_num_cleaned\0"
	"afs.yfs.vol_acl";

/*
 * Retrieve a list of the supported xattrs.
 */
ssize_t afs_listxattr(struct dentry *dentry, char *buffer, size_t size)
{
	if (size == 0)
		return sizeof(afs_xattr_list);
	if (size < sizeof(afs_xattr_list))
		return -ERANGE;
	memcpy(buffer, afs_xattr_list, sizeof(afs_xattr_list));
	return sizeof(afs_xattr_list);
}

/*
 * Deal with the result of a successful fetch ACL operation.
 */
static void afs_acl_success(struct afs_operation *op)
{
	afs_vnode_commit_status(op, &op->file[0]);
}

static void afs_acl_put(struct afs_operation *op)
{
	kfree(op->acl);
}

static const struct afs_operation_ops afs_fetch_acl_operation = {
	.issue_afs_rpc	= afs_fs_fetch_acl,
	.success	= afs_acl_success,
	.put		= afs_acl_put,
};

/*
 * Get a file's ACL.
 */
static int afs_xattr_get_acl(const struct xattr_handler *handler,
			     struct dentry *dentry,
			     struct inode *inode, const char *name,
			     void *buffer, size_t size)
{
	struct afs_operation *op;
	struct afs_vnode *vnode = AFS_FS_I(inode);
	struct afs_acl *acl = NULL;
	int ret;

	op = afs_alloc_operation(NULL, vnode->volume);
	if (IS_ERR(op))
		return -ENOMEM;

	afs_op_set_vnode(op, 0, vnode);
	op->ops = &afs_fetch_acl_operation;

	afs_begin_vnode_operation(op);
	afs_wait_for_operation(op);
	acl = op->acl;
	op->acl = NULL;
	ret = afs_put_operation(op);

	if (ret == 0) {
		ret = acl->size;
		if (size > 0) {
			if (acl->size <= size)
				memcpy(buffer, acl->data, acl->size);
			else
				op->error = -ERANGE;
		}
	}

	kfree(acl);
	return ret;
}

static bool afs_make_acl(struct afs_operation *op,
			 const void *buffer, size_t size)
{
	struct afs_acl *acl;

	acl = kmalloc(sizeof(*acl) + size, GFP_KERNEL);
	if (!acl) {
		afs_op_nomem(op);
		return false;
	}

	acl->size = size;
	memcpy(acl->data, buffer, size);
	op->acl = acl;
	return true;
}

static const struct afs_operation_ops afs_store_acl_operation = {
	.issue_afs_rpc	= afs_fs_store_acl,
	.success	= afs_acl_success,
	.put		= afs_acl_put,
};

/*
 * Set a file's AFS3 ACL.
 */
static int afs_xattr_set_acl(const struct xattr_handler *handler,
                             struct dentry *dentry,
                             struct inode *inode, const char *name,
                             const void *buffer, size_t size, int flags)
{
	struct afs_operation *op;
	struct afs_vnode *vnode = AFS_FS_I(inode);

	if (flags == XATTR_CREATE)
		return -EINVAL;

	op = afs_alloc_operation(NULL, vnode->volume);
	if (IS_ERR(op))
		return -ENOMEM;

	afs_op_set_vnode(op, 0, vnode);
	if (!afs_make_acl(op, buffer, size))
		return afs_put_operation(op);

	op->ops = &afs_store_acl_operation;
	return afs_do_sync_operation(op);
}

static const struct xattr_handler afs_xattr_afs_acl_handler = {
	.name   = "afs.acl",
	.get    = afs_xattr_get_acl,
	.set    = afs_xattr_set_acl,
};

static void yfs_acl_put(struct afs_operation *op)
{
	yfs_free_opaque_acl(op->yacl);
}

static const struct afs_operation_ops yfs_fetch_opaque_acl_operation = {
	.issue_yfs_rpc	= yfs_fs_fetch_opaque_acl,
	.success	= afs_acl_success,
	/* Don't free op->yacl in .put here */
};

/*
 * Get a file's YFS ACL.
 */
static int afs_xattr_get_yfs(const struct xattr_handler *handler,
			     struct dentry *dentry,
			     struct inode *inode, const char *name,
			     void *buffer, size_t size)
{
	struct afs_operation *op;
	struct afs_vnode *vnode = AFS_FS_I(inode);
	struct yfs_acl *yacl = NULL;
	char buf[16], *data;
	int which = 0, dsize, ret = -ENOMEM;

	if (strcmp(name, "acl") == 0)
		which = 0;
	else if (strcmp(name, "acl_inherited") == 0)
		which = 1;
	else if (strcmp(name, "acl_num_cleaned") == 0)
		which = 2;
	else if (strcmp(name, "vol_acl") == 0)
		which = 3;
	else
		return -EOPNOTSUPP;

	yacl = kzalloc(sizeof(struct yfs_acl), GFP_KERNEL);
	if (!yacl)
		goto error;

	if (which == 0)
		yacl->flags |= YFS_ACL_WANT_ACL;
	else if (which == 3)
		yacl->flags |= YFS_ACL_WANT_VOL_ACL;

	op = afs_alloc_operation(NULL, vnode->volume);
	if (IS_ERR(op))
		goto error_yacl;

	afs_op_set_vnode(op, 0, vnode);
	op->yacl = yacl;
	op->ops = &yfs_fetch_opaque_acl_operation;

	afs_begin_vnode_operation(op);
	afs_wait_for_operation(op);
	ret = afs_put_operation(op);

	if (ret == 0) {
		switch (which) {
		case 0:
			data = yacl->acl->data;
			dsize = yacl->acl->size;
			break;
		case 1:
			data = buf;
			dsize = scnprintf(buf, sizeof(buf), "%u", yacl->inherit_flag);
			break;
		case 2:
			data = buf;
			dsize = scnprintf(buf, sizeof(buf), "%u", yacl->num_cleaned);
			break;
		case 3:
			data = yacl->vol_acl->data;
			dsize = yacl->vol_acl->size;
			break;
		default:
			ret = -EOPNOTSUPP;
			goto error_yacl;
		}

		ret = dsize;
		if (size > 0) {
			if (dsize <= size)
				memcpy(buffer, data, dsize);
			else
				ret = -ERANGE;
		}
	}

error_yacl:
	yfs_free_opaque_acl(yacl);
error:
	return ret;
}

static const struct afs_operation_ops yfs_store_opaque_acl2_operation = {
	.issue_yfs_rpc	= yfs_fs_store_opaque_acl2,
	.success	= afs_acl_success,
	.put		= yfs_acl_put,
};

/*
 * Set a file's YFS ACL.
 */
static int afs_xattr_set_yfs(const struct xattr_handler *handler,
                             struct dentry *dentry,
                             struct inode *inode, const char *name,
                             const void *buffer, size_t size, int flags)
{
	struct afs_operation *op;
	struct afs_vnode *vnode = AFS_FS_I(inode);

	if (flags == XATTR_CREATE ||
	    strcmp(name, "acl") != 0)
		return -EINVAL;

	op = afs_alloc_operation(NULL, vnode->volume);
	if (IS_ERR(op))
		return -ENOMEM;

	afs_op_set_vnode(op, 0, vnode);
	if (!afs_make_acl(op, buffer, size))
		return afs_put_operation(op);

	op->ops = &yfs_store_opaque_acl2_operation;
	return afs_do_sync_operation(op);
}

static const struct xattr_handler afs_xattr_yfs_handler = {
	.prefix	= "afs.yfs.",
	.get	= afs_xattr_get_yfs,
	.set	= afs_xattr_set_yfs,
};

/*
 * Get the name of the cell on which a file resides.
 */
static int afs_xattr_get_cell(const struct xattr_handler *handler,
			      struct dentry *dentry,
			      struct inode *inode, const char *name,
			      void *buffer, size_t size)
{
	struct afs_vnode *vnode = AFS_FS_I(inode);
	struct afs_cell *cell = vnode->volume->cell;
	size_t namelen;

	namelen = cell->name_len;
	if (size == 0)
		return namelen;
	if (namelen > size)
		return -ERANGE;
	memcpy(buffer, cell->name, namelen);
	return namelen;
}

static const struct xattr_handler afs_xattr_afs_cell_handler = {
	.name	= "afs.cell",
	.get	= afs_xattr_get_cell,
};

/*
 * Get the volume ID, vnode ID and vnode uniquifier of a file as a sequence of
 * hex numbers separated by colons.
 */
static int afs_xattr_get_fid(const struct xattr_handler *handler,
			     struct dentry *dentry,
			     struct inode *inode, const char *name,
			     void *buffer, size_t size)
{
	struct afs_vnode *vnode = AFS_FS_I(inode);
	char text[16 + 1 + 24 + 1 + 8 + 1];
	size_t len;

	/* The volume ID is 64-bit, the vnode ID is 96-bit and the
	 * uniquifier is 32-bit.
	 */
	len = scnprintf(text, sizeof(text), "%llx:", vnode->fid.vid);
	if (vnode->fid.vnode_hi)
		len += scnprintf(text + len, sizeof(text) - len, "%x%016llx",
				vnode->fid.vnode_hi, vnode->fid.vnode);
	else
		len += scnprintf(text + len, sizeof(text) - len, "%llx",
				 vnode->fid.vnode);
	len += scnprintf(text + len, sizeof(text) - len, ":%x",
			 vnode->fid.unique);

	if (size == 0)
		return len;
	if (len > size)
		return -ERANGE;
	memcpy(buffer, text, len);
	return len;
}

static const struct xattr_handler afs_xattr_afs_fid_handler = {
	.name	= "afs.fid",
	.get	= afs_xattr_get_fid,
};

/*
 * Get the name of the volume on which a file resides.
 */
static int afs_xattr_get_volume(const struct xattr_handler *handler,
			      struct dentry *dentry,
			      struct inode *inode, const char *name,
			      void *buffer, size_t size)
{
	struct afs_vnode *vnode = AFS_FS_I(inode);
	const char *volname = vnode->volume->name;
	size_t namelen;

	namelen = strlen(volname);
	if (size == 0)
		return namelen;
	if (namelen > size)
		return -ERANGE;
	memcpy(buffer, volname, namelen);
	return namelen;
}

static const struct xattr_handler afs_xattr_afs_volume_handler = {
	.name	= "afs.volume",
	.get	= afs_xattr_get_volume,
};

const struct xattr_handler *afs_xattr_handlers[] = {
	&afs_xattr_afs_acl_handler,
	&afs_xattr_afs_cell_handler,
	&afs_xattr_afs_fid_handler,
	&afs_xattr_afs_volume_handler,
	&afs_xattr_yfs_handler,		/* afs.yfs. prefix */
	NULL
};
Commit	Line	Data
b4d0d230	1	// SPDX-License-Identifier: GPL-2.0-or-later
d3e3b7ea DH	2	/* Extended attribute handling for AFS. We use xattrs to get and set metadata
	3	* instead of providing pioctl().
	4	*
	5	* Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
	6	* Written by David Howells (dhowells@redhat.com)
d3e3b7ea DH	7	*/
	8
	9	#include <linux/slab.h>
	10	#include <linux/fs.h>
	11	#include <linux/xattr.h>
	12	#include "internal.h"
	13
	14	static const char afs_xattr_list[] =
260f082b	15	"afs.acl\0"
d3e3b7ea DH	16	"afs.cell\0"
d3e3b7ea DH	17	"afs.fid\0"
ae46578b DH	18	"afs.volume\0"
	19	"afs.yfs.acl\0"
	20	"afs.yfs.acl_inherited\0"
	21	"afs.yfs.acl_num_cleaned\0"
	22	"afs.yfs.vol_acl";
d3e3b7ea DH	23
	24	/*
	25	* Retrieve a list of the supported xattrs.
	26	*/
	27	ssize_t afs_listxattr(struct dentry dentry, char buffer, size_t size)
	28	{
	29	if (size == 0)
	30	return sizeof(afs_xattr_list);
	31	if (size < sizeof(afs_xattr_list))
	32	return -ERANGE;
	33	memcpy(buffer, afs_xattr_list, sizeof(afs_xattr_list));
	34	return sizeof(afs_xattr_list);
	35	}
	36
e49c7b2f DH	37	/*
	38	* Deal with the result of a successful fetch ACL operation.
	39	*/
	40	static void afs_acl_success(struct afs_operation *op)
	41	{
	42	afs_vnode_commit_status(op, &op->file[0]);
	43	}
	44
	45	static void afs_acl_put(struct afs_operation *op)
	46	{
	47	kfree(op->acl);
	48	}
	49
	50	static const struct afs_operation_ops afs_fetch_acl_operation = {
	51	.issue_afs_rpc = afs_fs_fetch_acl,
	52	.success = afs_acl_success,
	53	.put = afs_acl_put,
	54	};
	55
260f082b DH	56	/*
	57	* Get a file's ACL.
	58	*/
	59	static int afs_xattr_get_acl(const struct xattr_handler *handler,
	60	struct dentry *dentry,
	61	struct inode inode, const char name,
	62	void *buffer, size_t size)
	63	{
e49c7b2f	64	struct afs_operation *op;
260f082b DH	65	struct afs_vnode *vnode = AFS_FS_I(inode);
260f082b DH	66	struct afs_acl *acl = NULL;
e49c7b2f	67	int ret;
a58823ac	68
e49c7b2f DH	69	op = afs_alloc_operation(NULL, vnode->volume);
	70	if (IS_ERR(op))
	71	return -ENOMEM;
260f082b	72
e49c7b2f DH	73	afs_op_set_vnode(op, 0, vnode);
e49c7b2f DH	74	op->ops = &afs_fetch_acl_operation;
260f082b	75
e49c7b2f DH	76	afs_begin_vnode_operation(op);
	77	afs_wait_for_operation(op);
	78	acl = op->acl;
	79	op->acl = NULL;
	80	ret = afs_put_operation(op);
260f082b DH	81
	82	if (ret == 0) {
	83	ret = acl->size;
	84	if (size > 0) {
cc1dd5c8 DH	85	if (acl->size <= size)
	86	memcpy(buffer, acl->data, acl->size);
	87	else
e49c7b2f	88	op->error = -ERANGE;
260f082b	89	}
260f082b DH	90	}
260f082b DH	91
e49c7b2f	92	kfree(acl);
260f082b DH	93	return ret;
	94	}
	95
e49c7b2f DH	96	static bool afs_make_acl(struct afs_operation *op,
	97	const void *buffer, size_t size)
	98	{
	99	struct afs_acl *acl;
	100
	101	acl = kmalloc(sizeof(*acl) + size, GFP_KERNEL);
	102	if (!acl) {
	103	afs_op_nomem(op);
	104	return false;
	105	}
	106
	107	acl->size = size;
	108	memcpy(acl->data, buffer, size);
	109	op->acl = acl;
	110	return true;
	111	}
	112
	113	static const struct afs_operation_ops afs_store_acl_operation = {
	114	.issue_afs_rpc = afs_fs_store_acl,
	115	.success = afs_acl_success,
	116	.put = afs_acl_put,
	117	};
	118
b10494af JG	119	/*
	120	* Set a file's AFS3 ACL.
	121	*/
	122	static int afs_xattr_set_acl(const struct xattr_handler *handler,
	123	struct dentry *dentry,
	124	struct inode inode, const char name,
	125	const void *buffer, size_t size, int flags)
	126	{
e49c7b2f	127	struct afs_operation *op;
b10494af	128	struct afs_vnode *vnode = AFS_FS_I(inode);
b10494af JG	129
	130	if (flags == XATTR_CREATE)
	131	return -EINVAL;
	132
e49c7b2f DH	133	op = afs_alloc_operation(NULL, vnode->volume);
	134	if (IS_ERR(op))
	135	return -ENOMEM;
a58823ac	136
e49c7b2f DH	137	afs_op_set_vnode(op, 0, vnode);
	138	if (!afs_make_acl(op, buffer, size))
	139	return afs_put_operation(op);
b10494af	140
e49c7b2f DH	141	op->ops = &afs_store_acl_operation;
e49c7b2f DH	142	return afs_do_sync_operation(op);
b10494af JG	143	}
b10494af JG	144
260f082b	145	static const struct xattr_handler afs_xattr_afs_acl_handler = {
b10494af JG	146	.name = "afs.acl",
	147	.get = afs_xattr_get_acl,
	148	.set = afs_xattr_set_acl,
260f082b DH	149	};
260f082b DH	150
e49c7b2f DH	151	static void yfs_acl_put(struct afs_operation *op)
	152	{
	153	yfs_free_opaque_acl(op->yacl);
	154	}
	155
	156	static const struct afs_operation_ops yfs_fetch_opaque_acl_operation = {
	157	.issue_yfs_rpc = yfs_fs_fetch_opaque_acl,
	158	.success = afs_acl_success,
	159	/* Don't free op->yacl in .put here */
	160	};
	161
ae46578b DH	162	/*
	163	* Get a file's YFS ACL.
	164	*/
	165	static int afs_xattr_get_yfs(const struct xattr_handler *handler,
	166	struct dentry *dentry,
	167	struct inode inode, const char name,
	168	void *buffer, size_t size)
	169	{
e49c7b2f	170	struct afs_operation *op;
ae46578b DH	171	struct afs_vnode *vnode = AFS_FS_I(inode);
ae46578b DH	172	struct yfs_acl *yacl = NULL;
ae46578b	173	char buf[16], *data;
773e0c40	174	int which = 0, dsize, ret = -ENOMEM;
ae46578b DH	175
	176	if (strcmp(name, "acl") == 0)
	177	which = 0;
	178	else if (strcmp(name, "acl_inherited") == 0)
	179	which = 1;
	180	else if (strcmp(name, "acl_num_cleaned") == 0)
	181	which = 2;
	182	else if (strcmp(name, "vol_acl") == 0)
	183	which = 3;
	184	else
	185	return -EOPNOTSUPP;
	186
773e0c40 DH	187	yacl = kzalloc(sizeof(struct yfs_acl), GFP_KERNEL);
	188	if (!yacl)
	189	goto error;
	190
ae46578b	191	if (which == 0)
773e0c40	192	yacl->flags \|= YFS_ACL_WANT_ACL;
ae46578b	193	else if (which == 3)
773e0c40	194	yacl->flags \|= YFS_ACL_WANT_VOL_ACL;
ae46578b	195
e49c7b2f DH	196	op = afs_alloc_operation(NULL, vnode->volume);
e49c7b2f DH	197	if (IS_ERR(op))
a58823ac DH	198	goto error_yacl;
a58823ac DH	199
e49c7b2f DH	200	afs_op_set_vnode(op, 0, vnode);
	201	op->yacl = yacl;
	202	op->ops = &yfs_fetch_opaque_acl_operation;
ae46578b	203
e49c7b2f DH	204	afs_begin_vnode_operation(op);
	205	afs_wait_for_operation(op);
	206	ret = afs_put_operation(op);
a58823ac	207
e49c7b2f DH	208	if (ret == 0) {
	209	switch (which) {
	210	case 0:
	211	data = yacl->acl->data;
	212	dsize = yacl->acl->size;
	213	break;
	214	case 1:
	215	data = buf;
	216	dsize = scnprintf(buf, sizeof(buf), "%u", yacl->inherit_flag);
	217	break;
	218	case 2:
	219	data = buf;
	220	dsize = scnprintf(buf, sizeof(buf), "%u", yacl->num_cleaned);
	221	break;
	222	case 3:
	223	data = yacl->vol_acl->data;
	224	dsize = yacl->vol_acl->size;
	225	break;
	226	default:
	227	ret = -EOPNOTSUPP;
	228	goto error_yacl;
ae46578b DH	229	}
ae46578b DH	230
e49c7b2f DH	231	ret = dsize;
	232	if (size > 0) {
	233	if (dsize <= size)
	234	memcpy(buffer, data, dsize);
	235	else
	236	ret = -ERANGE;
ae46578b DH	237	}
	238	}
	239
773e0c40 DH	240	error_yacl:
	241	yfs_free_opaque_acl(yacl);
	242	error:
ae46578b DH	243	return ret;
	244	}
	245
e49c7b2f DH	246	static const struct afs_operation_ops yfs_store_opaque_acl2_operation = {
	247	.issue_yfs_rpc = yfs_fs_store_opaque_acl2,
	248	.success = afs_acl_success,
	249	.put = yfs_acl_put,
	250	};
	251
f5e45463 DH	252	/*
	253	* Set a file's YFS ACL.
	254	*/
	255	static int afs_xattr_set_yfs(const struct xattr_handler *handler,
	256	struct dentry *dentry,
	257	struct inode inode, const char name,
	258	const void *buffer, size_t size, int flags)
	259	{
e49c7b2f	260	struct afs_operation *op;
f5e45463	261	struct afs_vnode *vnode = AFS_FS_I(inode);
f5e45463 DH	262
	263	if (flags == XATTR_CREATE \|\|
	264	strcmp(name, "acl") != 0)
	265	return -EINVAL;
	266
e49c7b2f DH	267	op = afs_alloc_operation(NULL, vnode->volume);
	268	if (IS_ERR(op))
	269	return -ENOMEM;
f5e45463	270
e49c7b2f DH	271	afs_op_set_vnode(op, 0, vnode);
	272	if (!afs_make_acl(op, buffer, size))
	273	return afs_put_operation(op);
f5e45463	274
e49c7b2f DH	275	op->ops = &yfs_store_opaque_acl2_operation;
e49c7b2f DH	276	return afs_do_sync_operation(op);
f5e45463 DH	277	}
f5e45463 DH	278
ae46578b DH	279	static const struct xattr_handler afs_xattr_yfs_handler = {
	280	.prefix = "afs.yfs.",
	281	.get = afs_xattr_get_yfs,
f5e45463	282	.set = afs_xattr_set_yfs,
ae46578b DH	283	};
ae46578b DH	284
d3e3b7ea DH	285	/*
	286	* Get the name of the cell on which a file resides.
	287	*/
	288	static int afs_xattr_get_cell(const struct xattr_handler *handler,
	289	struct dentry *dentry,
	290	struct inode inode, const char name,
	291	void *buffer, size_t size)
	292	{
	293	struct afs_vnode *vnode = AFS_FS_I(inode);
	294	struct afs_cell *cell = vnode->volume->cell;
	295	size_t namelen;
	296
989782dc	297	namelen = cell->name_len;
d3e3b7ea DH	298	if (size == 0)
	299	return namelen;
	300	if (namelen > size)
	301	return -ERANGE;
c73aa410	302	memcpy(buffer, cell->name, namelen);
d3e3b7ea DH	303	return namelen;
	304	}
	305
	306	static const struct xattr_handler afs_xattr_afs_cell_handler = {
	307	.name = "afs.cell",
	308	.get = afs_xattr_get_cell,
	309	};
	310
	311	/*
	312	* Get the volume ID, vnode ID and vnode uniquifier of a file as a sequence of
	313	* hex numbers separated by colons.
	314	*/
	315	static int afs_xattr_get_fid(const struct xattr_handler *handler,
	316	struct dentry *dentry,
	317	struct inode inode, const char name,
	318	void *buffer, size_t size)
	319	{
	320	struct afs_vnode *vnode = AFS_FS_I(inode);
a2f611a3	321	char text[16 + 1 + 24 + 1 + 8 + 1];
d3e3b7ea DH	322	size_t len;
d3e3b7ea DH	323
a2f611a3 DH	324	/* The volume ID is 64-bit, the vnode ID is 96-bit and the
	325	* uniquifier is 32-bit.
	326	*/
2e2fae99	327	len = scnprintf(text, sizeof(text), "%llx:", vnode->fid.vid);
a2f611a3	328	if (vnode->fid.vnode_hi)
2e2fae99 MS	329	len += scnprintf(text + len, sizeof(text) - len, "%x%016llx",
2e2fae99 MS	330	vnode->fid.vnode_hi, vnode->fid.vnode);
a2f611a3	331	else
2e2fae99 MS	332	len += scnprintf(text + len, sizeof(text) - len, "%llx",
	333	vnode->fid.vnode);
	334	len += scnprintf(text + len, sizeof(text) - len, ":%x",
	335	vnode->fid.unique);
a2f611a3	336
d3e3b7ea DH	337	if (size == 0)
	338	return len;
	339	if (len > size)
	340	return -ERANGE;
	341	memcpy(buffer, text, len);
	342	return len;
	343	}
	344
	345	static const struct xattr_handler afs_xattr_afs_fid_handler = {
	346	.name = "afs.fid",
	347	.get = afs_xattr_get_fid,
	348	};
	349
	350	/*
	351	* Get the name of the volume on which a file resides.
	352	*/
	353	static int afs_xattr_get_volume(const struct xattr_handler *handler,
	354	struct dentry *dentry,
	355	struct inode inode, const char name,
	356	void *buffer, size_t size)
	357	{
	358	struct afs_vnode *vnode = AFS_FS_I(inode);
d2ddc776	359	const char *volname = vnode->volume->name;
d3e3b7ea DH	360	size_t namelen;
	361
	362	namelen = strlen(volname);
	363	if (size == 0)
	364	return namelen;
	365	if (namelen > size)
	366	return -ERANGE;
c73aa410	367	memcpy(buffer, volname, namelen);
d3e3b7ea DH	368	return namelen;
	369	}
	370
	371	static const struct xattr_handler afs_xattr_afs_volume_handler = {
	372	.name = "afs.volume",
	373	.get = afs_xattr_get_volume,
	374	};
	375
	376	const struct xattr_handler *afs_xattr_handlers[] = {
260f082b	377	&afs_xattr_afs_acl_handler,
d3e3b7ea DH	378	&afs_xattr_afs_cell_handler,
	379	&afs_xattr_afs_fid_handler,
	380	&afs_xattr_afs_volume_handler,
ae46578b	381	&afs_xattr_yfs_handler, /* afs.yfs. prefix */
d3e3b7ea DH	382	NULL
d3e3b7ea DH	383	};