fs/hfsplus/attributes.c - kernel/msm-4.9 - Gitiles

 /*
  * 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 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) {
 		len = strlen(name);
 		if (len > HFSPLUS_ATTR_MAX_STRLEN) {
 			printk(KERN_ERR "hfs: invalid xattr name's length\n");
 			return -EINVAL;
 		}
 		hfsplus_asc2uni(sb,
 				(struct hfsplus_unistr *)&key->attr.key_name,
 				HFSPLUS_ATTR_MAX_STRLEN, name, len);
 		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;
 }

 void hfsplus_attr_build_key_uni(hfsplus_btree_key *key,
 					u32 cnid,
 					struct hfsplus_attr_unistr *name)
 {
 	int ustrlen;

 	memset(key, 0, sizeof(struct hfsplus_attr_key));
 	ustrlen = be16_to_cpu(name->length);
 	key->attr.cnid = cpu_to_be32(cnid);
 	key->attr.key_name.length = cpu_to_be16(ustrlen);
 	ustrlen *= 2;
 	memcpy(key->attr.key_name.unicode, name->unicode, ustrlen);

 	/* 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) +
 				ustrlen);
 }

 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;

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

 	if (!HFSPLUS_SB(sb)->attr_tree) {
 		printk(KERN_ERR "hfs: 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;

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

 	if (!HFSPLUS_SB(sb)->attr_tree) {
 		printk(KERN_ERR "hfs: 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:
 		printk(KERN_ERR "hfs: only inline data xattr are supported\n");
 		return -EOPNOTSUPP;
 	default:
 		printk(KERN_ERR "hfs: 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;

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

 	if (!HFSPLUS_SB(sb)->attr_tree) {
 		printk(KERN_ERR "hfs: 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 {
 		printk(KERN_ERR "hfs: 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;

 	dprint(DBG_ATTR_MOD, "delete_all_attrs: %d\n", cnid);

 	if (!HFSPLUS_SB(dir->i_sb)->attr_tree) {
 		printk(KERN_ERR "hfs: 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)
 				printk(KERN_ERR "hfs: 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;
 }
	/*
	* 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 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) {
	len = strlen(name);
	if (len > HFSPLUS_ATTR_MAX_STRLEN) {
	printk(KERN_ERR "hfs: invalid xattr name's length\n");
	return -EINVAL;
	}
	hfsplus_asc2uni(sb,
	(struct hfsplus_unistr *)&key->attr.key_name,
	HFSPLUS_ATTR_MAX_STRLEN, name, len);
	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;
	}

	void hfsplus_attr_build_key_uni(hfsplus_btree_key *key,
	u32 cnid,
	struct hfsplus_attr_unistr *name)
	{
	int ustrlen;

	memset(key, 0, sizeof(struct hfsplus_attr_key));
	ustrlen = be16_to_cpu(name->length);
	key->attr.cnid = cpu_to_be32(cnid);
	key->attr.key_name.length = cpu_to_be16(ustrlen);
	ustrlen *= 2;
	memcpy(key->attr.key_name.unicode, name->unicode, ustrlen);

	/* 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) +
	ustrlen);
	}

	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;

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

	if (!HFSPLUS_SB(sb)->attr_tree) {
	printk(KERN_ERR "hfs: 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;

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

	if (!HFSPLUS_SB(sb)->attr_tree) {
	printk(KERN_ERR "hfs: 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:
	printk(KERN_ERR "hfs: only inline data xattr are supported\n");
	return -EOPNOTSUPP;
	default:
	printk(KERN_ERR "hfs: 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;

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

	if (!HFSPLUS_SB(sb)->attr_tree) {
	printk(KERN_ERR "hfs: 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 {
	printk(KERN_ERR "hfs: 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;

	dprint(DBG_ATTR_MOD, "delete_all_attrs: %d\n", cnid);

	if (!HFSPLUS_SB(dir->i_sb)->attr_tree) {
	printk(KERN_ERR "hfs: 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)
	printk(KERN_ERR "hfs: 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;
	}