[linux-2.6-block.git] / fs / hfsplus / attributes.c

/*
 * linux/fs/hfsplus/attributes.c
 *
 * Vyacheslav Dubeyko <slava@dubeyko.com>
 *
 * Handling of records in attributes tree
 */

#include "hfsplus_fs.h"
#include "hfsplus_raw.h"

static struct kmem_cache *hfsplus_attr_tree_cachep;

int __init hfsplus_create_attr_tree_cache(void)
{
	if (hfsplus_attr_tree_cachep)
		return -EEXIST;

	hfsplus_attr_tree_cachep =
		kmem_cache_create("hfsplus_attr_cache",
			sizeof(hfsplus_attr_entry), 0,
			SLAB_HWCACHE_ALIGN, NULL);
	if (!hfsplus_attr_tree_cachep)
		return -ENOMEM;

	return 0;
}

void hfsplus_destroy_attr_tree_cache(void)
{
	kmem_cache_destroy(hfsplus_attr_tree_cachep);
}

int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *k1,
				const hfsplus_btree_key *k2)
{
	__be32 k1_cnid, k2_cnid;

	k1_cnid = k1->attr.cnid;
	k2_cnid = k2->attr.cnid;
	if (k1_cnid != k2_cnid)
		return be32_to_cpu(k1_cnid) < be32_to_cpu(k2_cnid) ? -1 : 1;

	return hfsplus_strcmp(
			(const struct hfsplus_unistr *)&k1->attr.key_name,
			(const struct hfsplus_unistr *)&k2->attr.key_name);
}

int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
			u32 cnid, const char *name)
{
	int len;

	memset(key, 0, sizeof(struct hfsplus_attr_key));
	key->attr.cnid = cpu_to_be32(cnid);
	if (name) {
		int res = hfsplus_asc2uni(sb,
				(struct hfsplus_unistr *)&key->attr.key_name,
				HFSPLUS_ATTR_MAX_STRLEN, name, strlen(name));
		if (res)
			return res;
		len = be16_to_cpu(key->attr.key_name.length);
	} else {
		key->attr.key_name.length = 0;
		len = 0;
	}

	/* The length of the key, as stored in key_len field, does not include
	 * the size of the key_len field itself.
	 * So, offsetof(hfsplus_attr_key, key_name) is a trick because
	 * it takes into consideration key_len field (__be16) of
	 * hfsplus_attr_key structure instead of length field (__be16) of
	 * hfsplus_attr_unistr structure.
	 */
	key->key_len =
		cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) +
				2 * len);

	return 0;
}

hfsplus_attr_entry *hfsplus_alloc_attr_entry(void)
{
	return kmem_cache_alloc(hfsplus_attr_tree_cachep, GFP_KERNEL);
}

void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry)
{
	if (entry)
		kmem_cache_free(hfsplus_attr_tree_cachep, entry);
}

#define HFSPLUS_INVALID_ATTR_RECORD -1

static int hfsplus_attr_build_record(hfsplus_attr_entry *entry, int record_type,
				u32 cnid, const void *value, size_t size)
{
	if (record_type == HFSPLUS_ATTR_FORK_DATA) {
		/*
		 * Mac OS X supports only inline data attributes.
		 * Do nothing
		 */
		memset(entry, 0, sizeof(*entry));
		return sizeof(struct hfsplus_attr_fork_data);
	} else if (record_type == HFSPLUS_ATTR_EXTENTS) {
		/*
		 * Mac OS X supports only inline data attributes.
		 * Do nothing.
		 */
		memset(entry, 0, sizeof(*entry));
		return sizeof(struct hfsplus_attr_extents);
	} else if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
		u16 len;

		memset(entry, 0, sizeof(struct hfsplus_attr_inline_data));
		entry->inline_data.record_type = cpu_to_be32(record_type);
		if (size <= HFSPLUS_MAX_INLINE_DATA_SIZE)
			len = size;
		else
			return HFSPLUS_INVALID_ATTR_RECORD;
		entry->inline_data.length = cpu_to_be16(len);
		memcpy(entry->inline_data.raw_bytes, value, len);
		/*
		 * Align len on two-byte boundary.
		 * It needs to add pad byte if we have odd len.
		 */
		len = round_up(len, 2);
		return offsetof(struct hfsplus_attr_inline_data, raw_bytes) +
					len;
	} else /* invalid input */
		memset(entry, 0, sizeof(*entry));

	return HFSPLUS_INVALID_ATTR_RECORD;
}

int hfsplus_find_attr(struct super_block *sb, u32 cnid,
			const char *name, struct hfs_find_data *fd)
{
	int err = 0;

	hfs_dbg(ATTR_MOD, "find_attr: %s,%d\n", name ? name : NULL, cnid);

	if (!HFSPLUS_SB(sb)->attr_tree) {
		pr_err("attributes file doesn't exist\n");
		return -EINVAL;
	}

	if (name) {
		err = hfsplus_attr_build_key(sb, fd->search_key, cnid, name);
		if (err)
			goto failed_find_attr;
		err = hfs_brec_find(fd, hfs_find_rec_by_key);
		if (err)
			goto failed_find_attr;
	} else {
		err = hfsplus_attr_build_key(sb, fd->search_key, cnid, NULL);
		if (err)
			goto failed_find_attr;
		err = hfs_brec_find(fd, hfs_find_1st_rec_by_cnid);
		if (err)
			goto failed_find_attr;
	}

failed_find_attr:
	return err;
}

int hfsplus_attr_exists(struct inode *inode, const char *name)
{
	int err = 0;
	struct super_block *sb = inode->i_sb;
	struct hfs_find_data fd;

	if (!HFSPLUS_SB(sb)->attr_tree)
		return 0;

	err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
	if (err)
		return 0;

	err = hfsplus_find_attr(sb, inode->i_ino, name, &fd);
	if (err)
		goto attr_not_found;

	hfs_find_exit(&fd);
	return 1;

attr_not_found:
	hfs_find_exit(&fd);
	return 0;
}

int hfsplus_create_attr(struct inode *inode,
				const char *name,
				const void *value, size_t size)
{
	struct super_block *sb = inode->i_sb;
	struct hfs_find_data fd;
	hfsplus_attr_entry *entry_ptr;
	int entry_size;
	int err;

	hfs_dbg(ATTR_MOD, "create_attr: %s,%ld\n",
		name ? name : NULL, inode->i_ino);

	if (!HFSPLUS_SB(sb)->attr_tree) {
		pr_err("attributes file doesn't exist\n");
		return -EINVAL;
	}

	entry_ptr = hfsplus_alloc_attr_entry();
	if (!entry_ptr)
		return -ENOMEM;

	err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
	if (err)
		goto failed_init_create_attr;

	if (name) {
		err = hfsplus_attr_build_key(sb, fd.search_key,
						inode->i_ino, name);
		if (err)
			goto failed_create_attr;
	} else {
		err = -EINVAL;
		goto failed_create_attr;
	}

	/* Mac OS X supports only inline data attributes. */
	entry_size = hfsplus_attr_build_record(entry_ptr,
					HFSPLUS_ATTR_INLINE_DATA,
					inode->i_ino,
					value, size);
	if (entry_size == HFSPLUS_INVALID_ATTR_RECORD) {
		err = -EINVAL;
		goto failed_create_attr;
	}

	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	if (err != -ENOENT) {
		if (!err)
			err = -EEXIST;
		goto failed_create_attr;
	}

	err = hfs_brec_insert(&fd, entry_ptr, entry_size);
	if (err)
		goto failed_create_attr;

	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY);

failed_create_attr:
	hfs_find_exit(&fd);

failed_init_create_attr:
	hfsplus_destroy_attr_entry(entry_ptr);
	return err;
}

static int __hfsplus_delete_attr(struct inode *inode, u32 cnid,
					struct hfs_find_data *fd)
{
	int err = 0;
	__be32 found_cnid, record_type;

	hfs_bnode_read(fd->bnode, &found_cnid,
			fd->keyoffset +
			offsetof(struct hfsplus_attr_key, cnid),
			sizeof(__be32));
	if (cnid != be32_to_cpu(found_cnid))
		return -ENOENT;

	hfs_bnode_read(fd->bnode, &record_type,
			fd->entryoffset, sizeof(record_type));

	switch (be32_to_cpu(record_type)) {
	case HFSPLUS_ATTR_INLINE_DATA:
		/* All is OK. Do nothing. */
		break;
	case HFSPLUS_ATTR_FORK_DATA:
	case HFSPLUS_ATTR_EXTENTS:
		pr_err("only inline data xattr are supported\n");
		return -EOPNOTSUPP;
	default:
		pr_err("invalid extended attribute record\n");
		return -ENOENT;
	}

	err = hfs_brec_remove(fd);
	if (err)
		return err;

	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY);
	return err;
}

int hfsplus_delete_attr(struct inode *inode, const char *name)
{
	int err = 0;
	struct super_block *sb = inode->i_sb;
	struct hfs_find_data fd;

	hfs_dbg(ATTR_MOD, "delete_attr: %s,%ld\n",
		name ? name : NULL, inode->i_ino);

	if (!HFSPLUS_SB(sb)->attr_tree) {
		pr_err("attributes file doesn't exist\n");
		return -EINVAL;
	}

	err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
	if (err)
		return err;

	if (name) {
		err = hfsplus_attr_build_key(sb, fd.search_key,
						inode->i_ino, name);
		if (err)
			goto out;
	} else {
		pr_err("invalid extended attribute name\n");
		err = -EINVAL;
		goto out;
	}

	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	if (err)
		goto out;

	err = __hfsplus_delete_attr(inode, inode->i_ino, &fd);
	if (err)
		goto out;

out:
	hfs_find_exit(&fd);
	return err;
}

int hfsplus_delete_all_attrs(struct inode *dir, u32 cnid)
{
	int err = 0;
	struct hfs_find_data fd;

	hfs_dbg(ATTR_MOD, "delete_all_attrs: %d\n", cnid);

	if (!HFSPLUS_SB(dir->i_sb)->attr_tree) {
		pr_err("attributes file doesn't exist\n");
		return -EINVAL;
	}

	err = hfs_find_init(HFSPLUS_SB(dir->i_sb)->attr_tree, &fd);
	if (err)
		return err;

	for (;;) {
		err = hfsplus_find_attr(dir->i_sb, cnid, NULL, &fd);
		if (err) {
			if (err != -ENOENT)
				pr_err("xattr search failed\n");
			goto end_delete_all;
		}

		err = __hfsplus_delete_attr(dir, cnid, &fd);
		if (err)
			goto end_delete_all;
	}

end_delete_all:
	hfs_find_exit(&fd);
	return err;
}
Commit	Line	Data
3e05ca20 VD	1	/*
	2	* linux/fs/hfsplus/attributes.c
	3	*
	4	* Vyacheslav Dubeyko <slava@dubeyko.com>
	5	*
	6	* Handling of records in attributes tree
	7	*/
	8
	9	#include "hfsplus_fs.h"
	10	#include "hfsplus_raw.h"
	11
	12	static struct kmem_cache *hfsplus_attr_tree_cachep;
	13
c11e614d	14	int __init hfsplus_create_attr_tree_cache(void)
3e05ca20 VD	15	{
	16	if (hfsplus_attr_tree_cachep)
	17	return -EEXIST;
	18
	19	hfsplus_attr_tree_cachep =
	20	kmem_cache_create("hfsplus_attr_cache",
	21	sizeof(hfsplus_attr_entry), 0,
	22	SLAB_HWCACHE_ALIGN, NULL);
	23	if (!hfsplus_attr_tree_cachep)
	24	return -ENOMEM;
	25
	26	return 0;
	27	}
	28
	29	void hfsplus_destroy_attr_tree_cache(void)
	30	{
	31	kmem_cache_destroy(hfsplus_attr_tree_cachep);
	32	}
	33
	34	int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *k1,
	35	const hfsplus_btree_key *k2)
	36	{
	37	__be32 k1_cnid, k2_cnid;
	38
	39	k1_cnid = k1->attr.cnid;
	40	k2_cnid = k2->attr.cnid;
	41	if (k1_cnid != k2_cnid)
	42	return be32_to_cpu(k1_cnid) < be32_to_cpu(k2_cnid) ? -1 : 1;
	43
	44	return hfsplus_strcmp(
	45	(const struct hfsplus_unistr *)&k1->attr.key_name,
	46	(const struct hfsplus_unistr *)&k2->attr.key_name);
	47	}
	48
	49	int hfsplus_attr_build_key(struct super_block sb, hfsplus_btree_key key,
	50	u32 cnid, const char *name)
	51	{
	52	int len;
	53
	54	memset(key, 0, sizeof(struct hfsplus_attr_key));
	55	key->attr.cnid = cpu_to_be32(cnid);
	56	if (name) {
bf29e886	57	int res = hfsplus_asc2uni(sb,
3e05ca20	58	(struct hfsplus_unistr *)&key->attr.key_name,
bf29e886 HTL	59	HFSPLUS_ATTR_MAX_STRLEN, name, strlen(name));
	60	if (res)
	61	return res;
3e05ca20 VD	62	len = be16_to_cpu(key->attr.key_name.length);
	63	} else {
	64	key->attr.key_name.length = 0;
	65	len = 0;
	66	}
	67
	68	/* The length of the key, as stored in key_len field, does not include
	69	* the size of the key_len field itself.
	70	* So, offsetof(hfsplus_attr_key, key_name) is a trick because
	71	* it takes into consideration key_len field (__be16) of
	72	* hfsplus_attr_key structure instead of length field (__be16) of
	73	* hfsplus_attr_unistr structure.
	74	*/
	75	key->key_len =
	76	cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) +
	77	2 * len);
	78
	79	return 0;
	80	}
	81
3e05ca20 VD	82	hfsplus_attr_entry *hfsplus_alloc_attr_entry(void)
	83	{
	84	return kmem_cache_alloc(hfsplus_attr_tree_cachep, GFP_KERNEL);
	85	}
	86
	87	void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry)
	88	{
	89	if (entry)
	90	kmem_cache_free(hfsplus_attr_tree_cachep, entry);
	91	}
	92
	93	#define HFSPLUS_INVALID_ATTR_RECORD -1
	94
	95	static int hfsplus_attr_build_record(hfsplus_attr_entry *entry, int record_type,
	96	u32 cnid, const void *value, size_t size)
	97	{
	98	if (record_type == HFSPLUS_ATTR_FORK_DATA) {
	99	/*
	100	* Mac OS X supports only inline data attributes.
	101	* Do nothing
	102	*/
	103	memset(entry, 0, sizeof(*entry));
	104	return sizeof(struct hfsplus_attr_fork_data);
	105	} else if (record_type == HFSPLUS_ATTR_EXTENTS) {
	106	/*
	107	* Mac OS X supports only inline data attributes.
	108	* Do nothing.
	109	*/
	110	memset(entry, 0, sizeof(*entry));
	111	return sizeof(struct hfsplus_attr_extents);
	112	} else if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
	113	u16 len;
	114
	115	memset(entry, 0, sizeof(struct hfsplus_attr_inline_data));
	116	entry->inline_data.record_type = cpu_to_be32(record_type);
	117	if (size <= HFSPLUS_MAX_INLINE_DATA_SIZE)
	118	len = size;
	119	else
	120	return HFSPLUS_INVALID_ATTR_RECORD;
	121	entry->inline_data.length = cpu_to_be16(len);
	122	memcpy(entry->inline_data.raw_bytes, value, len);
	123	/*
	124	* Align len on two-byte boundary.
	125	* It needs to add pad byte if we have odd len.
	126	*/
	127	len = round_up(len, 2);
	128	return offsetof(struct hfsplus_attr_inline_data, raw_bytes) +
	129	len;
	130	} else /* invalid input */
	131	memset(entry, 0, sizeof(*entry));
	132
	133	return HFSPLUS_INVALID_ATTR_RECORD;
	134	}
	135
	136	int hfsplus_find_attr(struct super_block *sb, u32 cnid,
	137	const char name, struct hfs_find_data fd)
	138	{
	139	int err = 0;
	140
c2b3e1f7	141	hfs_dbg(ATTR_MOD, "find_attr: %s,%d\n", name ? name : NULL, cnid);
3e05ca20 VD	142
3e05ca20 VD	143	if (!HFSPLUS_SB(sb)->attr_tree) {
d6142673	144	pr_err("attributes file doesn't exist\n");
3e05ca20 VD	145	return -EINVAL;
	146	}
	147
	148	if (name) {
	149	err = hfsplus_attr_build_key(sb, fd->search_key, cnid, name);
	150	if (err)
	151	goto failed_find_attr;
	152	err = hfs_brec_find(fd, hfs_find_rec_by_key);
	153	if (err)
	154	goto failed_find_attr;
	155	} else {
	156	err = hfsplus_attr_build_key(sb, fd->search_key, cnid, NULL);
	157	if (err)
	158	goto failed_find_attr;
	159	err = hfs_brec_find(fd, hfs_find_1st_rec_by_cnid);
	160	if (err)
	161	goto failed_find_attr;
	162	}
	163
	164	failed_find_attr:
	165	return err;
	166	}
	167
	168	int hfsplus_attr_exists(struct inode inode, const char name)
	169	{
	170	int err = 0;
	171	struct super_block *sb = inode->i_sb;
	172	struct hfs_find_data fd;
	173
	174	if (!HFSPLUS_SB(sb)->attr_tree)
	175	return 0;
	176
	177	err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
	178	if (err)
	179	return 0;
	180
	181	err = hfsplus_find_attr(sb, inode->i_ino, name, &fd);
	182	if (err)
	183	goto attr_not_found;
	184
	185	hfs_find_exit(&fd);
	186	return 1;
	187
	188	attr_not_found:
	189	hfs_find_exit(&fd);
	190	return 0;
	191	}
	192
	193	int hfsplus_create_attr(struct inode *inode,
	194	const char *name,
	195	const void *value, size_t size)
	196	{
	197	struct super_block *sb = inode->i_sb;
	198	struct hfs_find_data fd;
	199	hfsplus_attr_entry *entry_ptr;
	200	int entry_size;
	201	int err;
	202
c2b3e1f7	203	hfs_dbg(ATTR_MOD, "create_attr: %s,%ld\n",
3e05ca20 VD	204	name ? name : NULL, inode->i_ino);
	205
	206	if (!HFSPLUS_SB(sb)->attr_tree) {
d6142673	207	pr_err("attributes file doesn't exist\n");
3e05ca20 VD	208	return -EINVAL;
	209	}
	210
	211	entry_ptr = hfsplus_alloc_attr_entry();
	212	if (!entry_ptr)
	213	return -ENOMEM;
	214
	215	err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
	216	if (err)
	217	goto failed_init_create_attr;
	218
	219	if (name) {
	220	err = hfsplus_attr_build_key(sb, fd.search_key,
	221	inode->i_ino, name);
	222	if (err)
	223	goto failed_create_attr;
	224	} else {
	225	err = -EINVAL;
	226	goto failed_create_attr;
	227	}
	228
	229	/* Mac OS X supports only inline data attributes. */
	230	entry_size = hfsplus_attr_build_record(entry_ptr,
	231	HFSPLUS_ATTR_INLINE_DATA,
	232	inode->i_ino,
	233	value, size);
	234	if (entry_size == HFSPLUS_INVALID_ATTR_RECORD) {
	235	err = -EINVAL;
	236	goto failed_create_attr;
	237	}
	238
	239	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	240	if (err != -ENOENT) {
	241	if (!err)
	242	err = -EEXIST;
	243	goto failed_create_attr;
	244	}
	245
	246	err = hfs_brec_insert(&fd, entry_ptr, entry_size);
	247	if (err)
	248	goto failed_create_attr;
	249
	250	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY);
	251
	252	failed_create_attr:
	253	hfs_find_exit(&fd);
	254
	255	failed_init_create_attr:
	256	hfsplus_destroy_attr_entry(entry_ptr);
	257	return err;
	258	}
	259
	260	static int __hfsplus_delete_attr(struct inode *inode, u32 cnid,
	261	struct hfs_find_data *fd)
	262	{
	263	int err = 0;
	264	__be32 found_cnid, record_type;
	265
	266	hfs_bnode_read(fd->bnode, &found_cnid,
	267	fd->keyoffset +
	268	offsetof(struct hfsplus_attr_key, cnid),
	269	sizeof(__be32));
	270	if (cnid != be32_to_cpu(found_cnid))
	271	return -ENOENT;
272
273	hfs_bnode_read(fd->bnode, &record_type,
274	fd->entryoffset, sizeof(record_type));
275
276	switch (be32_to_cpu(record_type)) {
277	case HFSPLUS_ATTR_INLINE_DATA:
278	/* All is OK. Do nothing. */
279	break;
280	case HFSPLUS_ATTR_FORK_DATA:
281	case HFSPLUS_ATTR_EXTENTS:
d6142673	282	pr_err("only inline data xattr are supported\n");
3e05ca20 VD	283	return -EOPNOTSUPP;
3e05ca20 VD	284	default:
d6142673	285	pr_err("invalid extended attribute record\n");
3e05ca20 VD	286	return -ENOENT;
	287	}
	288
	289	err = hfs_brec_remove(fd);
	290	if (err)
	291	return err;
	292
	293	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY);
	294	return err;
	295	}
	296
	297	int hfsplus_delete_attr(struct inode inode, const char name)
	298	{
	299	int err = 0;
	300	struct super_block *sb = inode->i_sb;
	301	struct hfs_find_data fd;
	302
c2b3e1f7	303	hfs_dbg(ATTR_MOD, "delete_attr: %s,%ld\n",
3e05ca20 VD	304	name ? name : NULL, inode->i_ino);
	305
	306	if (!HFSPLUS_SB(sb)->attr_tree) {
d6142673	307	pr_err("attributes file doesn't exist\n");
3e05ca20 VD	308	return -EINVAL;
	309	}
	310
	311	err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd);
	312	if (err)
	313	return err;
	314
	315	if (name) {
	316	err = hfsplus_attr_build_key(sb, fd.search_key,
	317	inode->i_ino, name);
	318	if (err)
	319	goto out;
	320	} else {
d6142673	321	pr_err("invalid extended attribute name\n");
3e05ca20 VD	322	err = -EINVAL;
	323	goto out;
	324	}
	325
	326	err = hfs_brec_find(&fd, hfs_find_rec_by_key);
	327	if (err)
	328	goto out;
	329
	330	err = __hfsplus_delete_attr(inode, inode->i_ino, &fd);
	331	if (err)
	332	goto out;
	333
	334	out:
	335	hfs_find_exit(&fd);
	336	return err;
	337	}
	338
	339	int hfsplus_delete_all_attrs(struct inode *dir, u32 cnid)
	340	{
	341	int err = 0;
	342	struct hfs_find_data fd;
	343
c2b3e1f7	344	hfs_dbg(ATTR_MOD, "delete_all_attrs: %d\n", cnid);
3e05ca20 VD	345
3e05ca20 VD	346	if (!HFSPLUS_SB(dir->i_sb)->attr_tree) {
d6142673	347	pr_err("attributes file doesn't exist\n");
3e05ca20 VD	348	return -EINVAL;
	349	}
	350
	351	err = hfs_find_init(HFSPLUS_SB(dir->i_sb)->attr_tree, &fd);
	352	if (err)
	353	return err;
	354
	355	for (;;) {
	356	err = hfsplus_find_attr(dir->i_sb, cnid, NULL, &fd);
	357	if (err) {
	358	if (err != -ENOENT)
d6142673	359	pr_err("xattr search failed\n");
3e05ca20 VD	360	goto end_delete_all;
	361	}
	362
	363	err = __hfsplus_delete_attr(dir, cnid, &fd);
	364	if (err)
	365	goto end_delete_all;
	366	}
	367
	368	end_delete_all:
	369	hfs_find_exit(&fd);
	370	return err;
	371	}