2 * linux/fs/hfsplus/xattr.c
4 * Vyacheslav Dubeyko <slava@dubeyko.com>
6 * Logic of processing extended attributes
9 #include "hfsplus_fs.h"
10 #include <linux/posix_acl_xattr.h>
14 static int hfsplus_removexattr(struct inode *inode, const char *name);
16 const struct xattr_handler *hfsplus_xattr_handlers[] = {
17 &hfsplus_xattr_osx_handler,
18 &hfsplus_xattr_user_handler,
19 &hfsplus_xattr_trusted_handler,
20 #ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
21 &posix_acl_access_xattr_handler,
22 &posix_acl_default_xattr_handler,
24 &hfsplus_xattr_security_handler,
28 static int strcmp_xattr_finder_info(const char *name)
31 return strncmp(name, HFSPLUS_XATTR_FINDER_INFO_NAME,
32 sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME));
37 static int strcmp_xattr_acl(const char *name)
40 return strncmp(name, HFSPLUS_XATTR_ACL_NAME,
41 sizeof(HFSPLUS_XATTR_ACL_NAME));
46 static inline int is_known_namespace(const char *name)
48 if (strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) &&
49 strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
50 strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
51 strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
57 static void hfsplus_init_header_node(struct inode *attr_file,
59 char *buf, u16 node_size)
61 struct hfs_bnode_desc *desc;
62 struct hfs_btree_header_rec *head;
65 u32 hdr_node_map_rec_bits;
71 hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %u\n",
72 clump_size, node_size);
74 /* The end of the node contains list of record offsets */
75 rec_offsets = (__be16 *)(buf + node_size);
77 desc = (struct hfs_bnode_desc *)buf;
78 desc->type = HFS_NODE_HEADER;
79 desc->num_recs = cpu_to_be16(HFSPLUS_BTREE_HDR_NODE_RECS_COUNT);
80 offset = sizeof(struct hfs_bnode_desc);
81 *--rec_offsets = cpu_to_be16(offset);
83 head = (struct hfs_btree_header_rec *)(buf + offset);
84 head->node_size = cpu_to_be16(node_size);
85 tmp = i_size_read(attr_file);
86 do_div(tmp, node_size);
87 head->node_count = cpu_to_be32(tmp);
88 head->free_nodes = cpu_to_be32(be32_to_cpu(head->node_count) - 1);
89 head->clump_size = cpu_to_be32(clump_size);
90 head->attributes |= cpu_to_be32(HFS_TREE_BIGKEYS | HFS_TREE_VARIDXKEYS);
91 head->max_key_len = cpu_to_be16(HFSPLUS_ATTR_KEYLEN - sizeof(u16));
92 offset += sizeof(struct hfs_btree_header_rec);
93 *--rec_offsets = cpu_to_be16(offset);
94 offset += HFSPLUS_BTREE_HDR_USER_BYTES;
95 *--rec_offsets = cpu_to_be16(offset);
97 hdr_node_map_rec_bits = 8 * (node_size - offset - (4 * sizeof(u16)));
98 if (be32_to_cpu(head->node_count) > hdr_node_map_rec_bits) {
102 desc->next = cpu_to_be32(be32_to_cpu(head->leaf_tail) + 1);
103 map_node_bits = 8 * (node_size - sizeof(struct hfs_bnode_desc) -
104 (2 * sizeof(u16)) - 2);
105 map_nodes = (be32_to_cpu(head->node_count) -
106 hdr_node_map_rec_bits +
107 (map_node_bits - 1)) / map_node_bits;
108 be32_add_cpu(&head->free_nodes, 0 - map_nodes);
113 be32_to_cpu(head->node_count) - be32_to_cpu(head->free_nodes);
114 used_bmp_bytes = used_nodes / 8;
115 if (used_bmp_bytes) {
116 memset(bmp, 0xFF, used_bmp_bytes);
117 bmp += used_bmp_bytes;
120 *bmp = ~(0xFF >> used_nodes);
121 offset += hdr_node_map_rec_bits / 8;
122 *--rec_offsets = cpu_to_be16(offset);
125 static int hfsplus_create_attributes_file(struct super_block *sb)
128 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
129 struct inode *attr_file;
130 struct hfsplus_inode_info *hip;
132 u16 node_size = HFSPLUS_ATTR_TREE_NODE_SIZE;
135 struct address_space *mapping;
137 int old_state = HFSPLUS_EMPTY_ATTR_TREE;
139 hfs_dbg(ATTR_MOD, "create_attr_file: ino %d\n", HFSPLUS_ATTR_CNID);
141 check_attr_tree_state_again:
142 switch (atomic_read(&sbi->attr_tree_state)) {
143 case HFSPLUS_EMPTY_ATTR_TREE:
144 if (old_state != atomic_cmpxchg(&sbi->attr_tree_state,
146 HFSPLUS_CREATING_ATTR_TREE))
147 goto check_attr_tree_state_again;
149 case HFSPLUS_CREATING_ATTR_TREE:
151 * This state means that another thread is in process
152 * of AttributesFile creation. Theoretically, it is
153 * possible to be here. But really __setxattr() method
154 * first of all calls hfs_find_init() for lookup in
155 * B-tree of CatalogFile. This method locks mutex of
156 * CatalogFile's B-tree. As a result, if some thread
157 * is inside AttributedFile creation operation then
158 * another threads will be waiting unlocking of
159 * CatalogFile's B-tree's mutex. However, if code will
160 * change then we will return error code (-EAGAIN) from
161 * here. Really, it means that first try to set of xattr
162 * fails with error but second attempt will have success.
165 case HFSPLUS_VALID_ATTR_TREE:
167 case HFSPLUS_FAILED_ATTR_TREE:
173 attr_file = hfsplus_iget(sb, HFSPLUS_ATTR_CNID);
174 if (IS_ERR(attr_file)) {
175 pr_err("failed to load attributes file\n");
176 return PTR_ERR(attr_file);
179 BUG_ON(i_size_read(attr_file) != 0);
181 hip = HFSPLUS_I(attr_file);
183 clump_size = hfsplus_calc_btree_clump_size(sb->s_blocksize,
188 mutex_lock(&hip->extents_lock);
189 hip->clump_blocks = clump_size >> sbi->alloc_blksz_shift;
190 mutex_unlock(&hip->extents_lock);
192 if (sbi->free_blocks <= (hip->clump_blocks << 1)) {
194 goto end_attr_file_creation;
197 while (hip->alloc_blocks < hip->clump_blocks) {
198 err = hfsplus_file_extend(attr_file);
200 pr_err("failed to extend attributes file\n");
201 goto end_attr_file_creation;
203 hip->phys_size = attr_file->i_size =
204 (loff_t)hip->alloc_blocks << sbi->alloc_blksz_shift;
205 hip->fs_blocks = hip->alloc_blocks << sbi->fs_shift;
206 inode_set_bytes(attr_file, attr_file->i_size);
209 buf = kzalloc(node_size, GFP_NOFS);
211 pr_err("failed to allocate memory for header node\n");
213 goto end_attr_file_creation;
216 hfsplus_init_header_node(attr_file, clump_size, buf, node_size);
218 mapping = attr_file->i_mapping;
222 for (; written < node_size; index++, written += PAGE_CACHE_SIZE) {
225 page = read_mapping_page(mapping, index, NULL);
228 goto failed_header_node_init;
231 kaddr = kmap_atomic(page);
232 memcpy(kaddr, buf + written,
233 min_t(size_t, PAGE_CACHE_SIZE, node_size - written));
234 kunmap_atomic(kaddr);
236 set_page_dirty(page);
237 page_cache_release(page);
240 hfsplus_mark_inode_dirty(attr_file, HFSPLUS_I_ATTR_DIRTY);
242 sbi->attr_tree = hfs_btree_open(sb, HFSPLUS_ATTR_CNID);
244 pr_err("failed to load attributes file\n");
246 failed_header_node_init:
249 end_attr_file_creation:
253 atomic_set(&sbi->attr_tree_state, HFSPLUS_VALID_ATTR_TREE);
254 else if (err == -ENOSPC)
255 atomic_set(&sbi->attr_tree_state, HFSPLUS_EMPTY_ATTR_TREE);
257 atomic_set(&sbi->attr_tree_state, HFSPLUS_FAILED_ATTR_TREE);
262 int __hfsplus_setxattr(struct inode *inode, const char *name,
263 const void *value, size_t size, int flags)
266 struct hfs_find_data cat_fd;
267 hfsplus_cat_entry entry;
268 u16 cat_entry_flags, cat_entry_type;
269 u16 folder_finderinfo_len = sizeof(struct DInfo) +
270 sizeof(struct DXInfo);
271 u16 file_finderinfo_len = sizeof(struct FInfo) +
272 sizeof(struct FXInfo);
274 if ((!S_ISREG(inode->i_mode) &&
275 !S_ISDIR(inode->i_mode)) ||
276 HFSPLUS_IS_RSRC(inode))
280 return hfsplus_removexattr(inode, name);
282 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
284 pr_err("can't init xattr find struct\n");
288 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
290 pr_err("catalog searching failed\n");
294 if (!strcmp_xattr_finder_info(name)) {
295 if (flags & XATTR_CREATE) {
296 pr_err("xattr exists yet\n");
300 hfs_bnode_read(cat_fd.bnode, &entry, cat_fd.entryoffset,
301 sizeof(hfsplus_cat_entry));
302 if (be16_to_cpu(entry.type) == HFSPLUS_FOLDER) {
303 if (size == folder_finderinfo_len) {
304 memcpy(&entry.folder.user_info, value,
305 folder_finderinfo_len);
306 hfs_bnode_write(cat_fd.bnode, &entry,
308 sizeof(struct hfsplus_cat_folder));
309 hfsplus_mark_inode_dirty(inode,
310 HFSPLUS_I_CAT_DIRTY);
315 } else if (be16_to_cpu(entry.type) == HFSPLUS_FILE) {
316 if (size == file_finderinfo_len) {
317 memcpy(&entry.file.user_info, value,
318 file_finderinfo_len);
319 hfs_bnode_write(cat_fd.bnode, &entry,
321 sizeof(struct hfsplus_cat_file));
322 hfsplus_mark_inode_dirty(inode,
323 HFSPLUS_I_CAT_DIRTY);
335 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) {
336 err = hfsplus_create_attributes_file(inode->i_sb);
341 if (hfsplus_attr_exists(inode, name)) {
342 if (flags & XATTR_CREATE) {
343 pr_err("xattr exists yet\n");
347 err = hfsplus_delete_attr(inode, name);
350 err = hfsplus_create_attr(inode, name, value, size);
354 if (flags & XATTR_REPLACE) {
355 pr_err("cannot replace xattr\n");
359 err = hfsplus_create_attr(inode, name, value, size);
364 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
365 if (cat_entry_type == HFSPLUS_FOLDER) {
366 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
368 offsetof(struct hfsplus_cat_folder, flags));
369 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
370 if (!strcmp_xattr_acl(name))
371 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
372 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
373 offsetof(struct hfsplus_cat_folder, flags),
375 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
376 } else if (cat_entry_type == HFSPLUS_FILE) {
377 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
379 offsetof(struct hfsplus_cat_file, flags));
380 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
381 if (!strcmp_xattr_acl(name))
382 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
383 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
384 offsetof(struct hfsplus_cat_file, flags),
386 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
388 pr_err("invalid catalog entry type\n");
394 hfs_find_exit(&cat_fd);
398 static int name_len(const char *xattr_name, int xattr_name_len)
400 int len = xattr_name_len + 1;
402 if (!is_known_namespace(xattr_name))
403 len += XATTR_MAC_OSX_PREFIX_LEN;
408 static int copy_name(char *buffer, const char *xattr_name, int name_len)
413 if (!is_known_namespace(xattr_name)) {
414 strncpy(buffer, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN);
415 offset += XATTR_MAC_OSX_PREFIX_LEN;
416 len += XATTR_MAC_OSX_PREFIX_LEN;
419 strncpy(buffer + offset, xattr_name, name_len);
420 memset(buffer + offset + name_len, 0, 1);
426 static ssize_t hfsplus_getxattr_finder_info(struct inode *inode,
427 void *value, size_t size)
430 struct hfs_find_data fd;
432 u16 folder_rec_len = sizeof(struct DInfo) + sizeof(struct DXInfo);
433 u16 file_rec_len = sizeof(struct FInfo) + sizeof(struct FXInfo);
434 u16 record_len = max(folder_rec_len, file_rec_len);
435 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
436 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
438 if (size >= record_len) {
439 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
441 pr_err("can't init xattr find struct\n");
444 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
446 goto end_getxattr_finder_info;
447 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
449 if (entry_type == HFSPLUS_FOLDER) {
450 hfs_bnode_read(fd.bnode, folder_finder_info,
452 offsetof(struct hfsplus_cat_folder, user_info),
454 memcpy(value, folder_finder_info, folder_rec_len);
455 res = folder_rec_len;
456 } else if (entry_type == HFSPLUS_FILE) {
457 hfs_bnode_read(fd.bnode, file_finder_info,
459 offsetof(struct hfsplus_cat_file, user_info),
461 memcpy(value, file_finder_info, file_rec_len);
465 goto end_getxattr_finder_info;
468 res = size ? -ERANGE : record_len;
470 end_getxattr_finder_info:
471 if (size >= record_len)
476 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
477 void *value, size_t size)
479 struct hfs_find_data fd;
480 hfsplus_attr_entry *entry;
481 __be32 xattr_record_type;
483 u16 record_length = 0;
486 if ((!S_ISREG(inode->i_mode) &&
487 !S_ISDIR(inode->i_mode)) ||
488 HFSPLUS_IS_RSRC(inode))
491 if (!strcmp_xattr_finder_info(name))
492 return hfsplus_getxattr_finder_info(inode, value, size);
494 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
497 entry = hfsplus_alloc_attr_entry();
499 pr_err("can't allocate xattr entry\n");
503 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
505 pr_err("can't init xattr find struct\n");
506 goto failed_getxattr_init;
509 res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd);
514 pr_err("xattr searching failed\n");
518 hfs_bnode_read(fd.bnode, &xattr_record_type,
519 fd.entryoffset, sizeof(xattr_record_type));
520 record_type = be32_to_cpu(xattr_record_type);
521 if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
522 record_length = hfs_bnode_read_u16(fd.bnode,
524 offsetof(struct hfsplus_attr_inline_data,
526 if (record_length > HFSPLUS_MAX_INLINE_DATA_SIZE) {
527 pr_err("invalid xattr record size\n");
531 } else if (record_type == HFSPLUS_ATTR_FORK_DATA ||
532 record_type == HFSPLUS_ATTR_EXTENTS) {
533 pr_err("only inline data xattr are supported\n");
537 pr_err("invalid xattr record\n");
543 hfs_bnode_read(fd.bnode, entry, fd.entryoffset,
544 offsetof(struct hfsplus_attr_inline_data,
545 raw_bytes) + record_length);
548 if (size >= record_length) {
549 memcpy(value, entry->inline_data.raw_bytes, record_length);
552 res = size ? -ERANGE : record_length;
557 failed_getxattr_init:
558 hfsplus_destroy_attr_entry(entry);
562 static inline int can_list(const char *xattr_name)
567 return strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
568 XATTR_TRUSTED_PREFIX_LEN) ||
569 capable(CAP_SYS_ADMIN);
572 static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
573 char *buffer, size_t size)
576 struct inode *inode = dentry->d_inode;
577 struct hfs_find_data fd;
579 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
580 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
581 unsigned long len, found_bit;
582 int xattr_name_len, symbols_count;
584 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
586 pr_err("can't init xattr find struct\n");
590 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
592 goto end_listxattr_finder_info;
594 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
595 if (entry_type == HFSPLUS_FOLDER) {
596 len = sizeof(struct DInfo) + sizeof(struct DXInfo);
597 hfs_bnode_read(fd.bnode, folder_finder_info,
599 offsetof(struct hfsplus_cat_folder, user_info),
601 found_bit = find_first_bit((void *)folder_finder_info, len*8);
602 } else if (entry_type == HFSPLUS_FILE) {
603 len = sizeof(struct FInfo) + sizeof(struct FXInfo);
604 hfs_bnode_read(fd.bnode, file_finder_info,
606 offsetof(struct hfsplus_cat_file, user_info),
608 found_bit = find_first_bit((void *)file_finder_info, len*8);
611 goto end_listxattr_finder_info;
614 if (found_bit >= (len*8))
617 symbols_count = sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME) - 1;
619 name_len(HFSPLUS_XATTR_FINDER_INFO_NAME, symbols_count);
620 if (!buffer || !size) {
621 if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME))
622 res = xattr_name_len;
623 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) {
624 if (size < xattr_name_len)
627 res = copy_name(buffer,
628 HFSPLUS_XATTR_FINDER_INFO_NAME,
634 end_listxattr_finder_info:
640 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
644 struct inode *inode = dentry->d_inode;
645 struct hfs_find_data fd;
647 struct hfsplus_attr_key attr_key;
648 char strbuf[HFSPLUS_ATTR_MAX_STRLEN +
649 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
652 if ((!S_ISREG(inode->i_mode) &&
653 !S_ISDIR(inode->i_mode)) ||
654 HFSPLUS_IS_RSRC(inode))
657 res = hfsplus_listxattr_finder_info(dentry, buffer, size);
660 else if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
661 return (res == 0) ? -EOPNOTSUPP : res;
663 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
665 pr_err("can't init xattr find struct\n");
669 err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
671 if (err == -ENOENT) {
682 key_len = hfs_bnode_read_u16(fd.bnode, fd.keyoffset);
683 if (key_len == 0 || key_len > fd.tree->max_key_len) {
684 pr_err("invalid xattr key length: %d\n", key_len);
689 hfs_bnode_read(fd.bnode, &attr_key,
690 fd.keyoffset, key_len + sizeof(key_len));
692 if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
695 xattr_name_len = HFSPLUS_ATTR_MAX_STRLEN;
696 if (hfsplus_uni2asc(inode->i_sb,
697 (const struct hfsplus_unistr *)&fd.key->attr.key_name,
698 strbuf, &xattr_name_len)) {
699 pr_err("unicode conversion failed\n");
704 if (!buffer || !size) {
705 if (can_list(strbuf))
706 res += name_len(strbuf, xattr_name_len);
707 } else if (can_list(strbuf)) {
708 if (size < (res + name_len(strbuf, xattr_name_len))) {
712 res += copy_name(buffer + res,
713 strbuf, xattr_name_len);
716 if (hfs_brec_goto(&fd, 1))
725 static int hfsplus_removexattr(struct inode *inode, const char *name)
728 struct hfs_find_data cat_fd;
731 int is_xattr_acl_deleted = 0;
732 int is_all_xattrs_deleted = 0;
734 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
737 if (!strcmp_xattr_finder_info(name))
740 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
742 pr_err("can't init xattr find struct\n");
746 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
748 pr_err("catalog searching failed\n");
749 goto end_removexattr;
752 err = hfsplus_delete_attr(inode, name);
754 goto end_removexattr;
756 is_xattr_acl_deleted = !strcmp_xattr_acl(name);
757 is_all_xattrs_deleted = !hfsplus_attr_exists(inode, NULL);
759 if (!is_xattr_acl_deleted && !is_all_xattrs_deleted)
760 goto end_removexattr;
762 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
764 if (cat_entry_type == HFSPLUS_FOLDER) {
765 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
766 offsetof(struct hfsplus_cat_folder, flags));
767 if (is_xattr_acl_deleted)
768 flags &= ~HFSPLUS_ACL_EXISTS;
769 if (is_all_xattrs_deleted)
770 flags &= ~HFSPLUS_XATTR_EXISTS;
771 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
772 offsetof(struct hfsplus_cat_folder, flags),
774 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
775 } else if (cat_entry_type == HFSPLUS_FILE) {
776 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
777 offsetof(struct hfsplus_cat_file, flags));
778 if (is_xattr_acl_deleted)
779 flags &= ~HFSPLUS_ACL_EXISTS;
780 if (is_all_xattrs_deleted)
781 flags &= ~HFSPLUS_XATTR_EXISTS;
782 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
783 offsetof(struct hfsplus_cat_file, flags),
785 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
787 pr_err("invalid catalog entry type\n");
789 goto end_removexattr;
793 hfs_find_exit(&cat_fd);
797 static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name,
798 void *buffer, size_t size, int type)
800 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
801 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
802 size_t len = strlen(name);
804 if (!strcmp(name, ""))
807 if (len > HFSPLUS_ATTR_MAX_STRLEN)
811 * Don't allow retrieving properly prefixed attributes
812 * by prepending them with "osx."
814 if (is_known_namespace(name))
817 return hfsplus_getxattr(dentry, xattr_name, buffer, size);
820 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
821 const void *buffer, size_t size, int flags, int type)
823 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
824 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
825 size_t len = strlen(name);
827 if (!strcmp(name, ""))
830 if (len > HFSPLUS_ATTR_MAX_STRLEN)
834 * Don't allow setting properly prefixed attributes
835 * by prepending them with "osx."
837 if (is_known_namespace(name))
840 return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
843 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,
844 size_t list_size, const char *name, size_t name_len, int type)
847 * This method is not used.
848 * It is used hfsplus_listxattr() instead of generic_listxattr().
853 const struct xattr_handler hfsplus_xattr_osx_handler = {
854 .prefix = XATTR_MAC_OSX_PREFIX,
855 .list = hfsplus_osx_listxattr,
856 .get = hfsplus_osx_getxattr,
857 .set = hfsplus_osx_setxattr,