[linux-block.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"

/*
 * 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
				ret = -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 mnt_idmap *idmap,
                             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 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;
		}
	} else if (ret == -ENOTSUPP) {
		ret = -ENODATA;
	}

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		= afs_acl_put,
};

/*
 * Set a file's YFS ACL.
 */
static int afs_xattr_set_yfs(const struct xattr_handler *handler,
			     struct mnt_idmap *idmap,
                             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);
	int ret;

	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;
	ret = afs_do_sync_operation(op);
	if (ret == -ENOTSUPP)
		ret = -ENODATA;
	return ret;
}

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