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>
11 #include <linux/nls.h>
15 static int hfsplus_removexattr(struct inode *inode, const char *name);
17 const struct xattr_handler *hfsplus_xattr_handlers[] = {
18 &hfsplus_xattr_osx_handler,
19 &hfsplus_xattr_user_handler,
20 &hfsplus_xattr_trusted_handler,
21 #ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
22 &posix_acl_access_xattr_handler,
23 &posix_acl_default_xattr_handler,
25 &hfsplus_xattr_security_handler,
29 static int strcmp_xattr_finder_info(const char *name)
32 return strncmp(name, HFSPLUS_XATTR_FINDER_INFO_NAME,
33 sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME));
38 static int strcmp_xattr_acl(const char *name)
41 return strncmp(name, HFSPLUS_XATTR_ACL_NAME,
42 sizeof(HFSPLUS_XATTR_ACL_NAME));
47 static inline int is_known_namespace(const char *name)
49 if (strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) &&
50 strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
51 strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
52 strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
58 static void hfsplus_init_header_node(struct inode *attr_file,
60 char *buf, u16 node_size)
62 struct hfs_bnode_desc *desc;
63 struct hfs_btree_header_rec *head;
66 u32 hdr_node_map_rec_bits;
72 hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %u\n",
73 clump_size, node_size);
75 /* The end of the node contains list of record offsets */
76 rec_offsets = (__be16 *)(buf + node_size);
78 desc = (struct hfs_bnode_desc *)buf;
79 desc->type = HFS_NODE_HEADER;
80 desc->num_recs = cpu_to_be16(HFSPLUS_BTREE_HDR_NODE_RECS_COUNT);
81 offset = sizeof(struct hfs_bnode_desc);
82 *--rec_offsets = cpu_to_be16(offset);
84 head = (struct hfs_btree_header_rec *)(buf + offset);
85 head->node_size = cpu_to_be16(node_size);
86 tmp = i_size_read(attr_file);
87 do_div(tmp, node_size);
88 head->node_count = cpu_to_be32(tmp);
89 head->free_nodes = cpu_to_be32(be32_to_cpu(head->node_count) - 1);
90 head->clump_size = cpu_to_be32(clump_size);
91 head->attributes |= cpu_to_be32(HFS_TREE_BIGKEYS | HFS_TREE_VARIDXKEYS);
92 head->max_key_len = cpu_to_be16(HFSPLUS_ATTR_KEYLEN - sizeof(u16));
93 offset += sizeof(struct hfs_btree_header_rec);
94 *--rec_offsets = cpu_to_be16(offset);
95 offset += HFSPLUS_BTREE_HDR_USER_BYTES;
96 *--rec_offsets = cpu_to_be16(offset);
98 hdr_node_map_rec_bits = 8 * (node_size - offset - (4 * sizeof(u16)));
99 if (be32_to_cpu(head->node_count) > hdr_node_map_rec_bits) {
103 desc->next = cpu_to_be32(be32_to_cpu(head->leaf_tail) + 1);
104 map_node_bits = 8 * (node_size - sizeof(struct hfs_bnode_desc) -
105 (2 * sizeof(u16)) - 2);
106 map_nodes = (be32_to_cpu(head->node_count) -
107 hdr_node_map_rec_bits +
108 (map_node_bits - 1)) / map_node_bits;
109 be32_add_cpu(&head->free_nodes, 0 - map_nodes);
114 be32_to_cpu(head->node_count) - be32_to_cpu(head->free_nodes);
115 used_bmp_bytes = used_nodes / 8;
116 if (used_bmp_bytes) {
117 memset(bmp, 0xFF, used_bmp_bytes);
118 bmp += used_bmp_bytes;
121 *bmp = ~(0xFF >> used_nodes);
122 offset += hdr_node_map_rec_bits / 8;
123 *--rec_offsets = cpu_to_be16(offset);
126 static int hfsplus_create_attributes_file(struct super_block *sb)
129 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
130 struct inode *attr_file;
131 struct hfsplus_inode_info *hip;
133 u16 node_size = HFSPLUS_ATTR_TREE_NODE_SIZE;
136 struct address_space *mapping;
138 int old_state = HFSPLUS_EMPTY_ATTR_TREE;
140 hfs_dbg(ATTR_MOD, "create_attr_file: ino %d\n", HFSPLUS_ATTR_CNID);
142 check_attr_tree_state_again:
143 switch (atomic_read(&sbi->attr_tree_state)) {
144 case HFSPLUS_EMPTY_ATTR_TREE:
145 if (old_state != atomic_cmpxchg(&sbi->attr_tree_state,
147 HFSPLUS_CREATING_ATTR_TREE))
148 goto check_attr_tree_state_again;
150 case HFSPLUS_CREATING_ATTR_TREE:
152 * This state means that another thread is in process
153 * of AttributesFile creation. Theoretically, it is
154 * possible to be here. But really __setxattr() method
155 * first of all calls hfs_find_init() for lookup in
156 * B-tree of CatalogFile. This method locks mutex of
157 * CatalogFile's B-tree. As a result, if some thread
158 * is inside AttributedFile creation operation then
159 * another threads will be waiting unlocking of
160 * CatalogFile's B-tree's mutex. However, if code will
161 * change then we will return error code (-EAGAIN) from
162 * here. Really, it means that first try to set of xattr
163 * fails with error but second attempt will have success.
166 case HFSPLUS_VALID_ATTR_TREE:
168 case HFSPLUS_FAILED_ATTR_TREE:
174 attr_file = hfsplus_iget(sb, HFSPLUS_ATTR_CNID);
175 if (IS_ERR(attr_file)) {
176 pr_err("failed to load attributes file\n");
177 return PTR_ERR(attr_file);
180 BUG_ON(i_size_read(attr_file) != 0);
182 hip = HFSPLUS_I(attr_file);
184 clump_size = hfsplus_calc_btree_clump_size(sb->s_blocksize,
189 mutex_lock(&hip->extents_lock);
190 hip->clump_blocks = clump_size >> sbi->alloc_blksz_shift;
191 mutex_unlock(&hip->extents_lock);
193 if (sbi->free_blocks <= (hip->clump_blocks << 1)) {
195 goto end_attr_file_creation;
198 while (hip->alloc_blocks < hip->clump_blocks) {
199 err = hfsplus_file_extend(attr_file);
201 pr_err("failed to extend attributes file\n");
202 goto end_attr_file_creation;
204 hip->phys_size = attr_file->i_size =
205 (loff_t)hip->alloc_blocks << sbi->alloc_blksz_shift;
206 hip->fs_blocks = hip->alloc_blocks << sbi->fs_shift;
207 inode_set_bytes(attr_file, attr_file->i_size);
210 buf = kzalloc(node_size, GFP_NOFS);
212 pr_err("failed to allocate memory for header node\n");
214 goto end_attr_file_creation;
217 hfsplus_init_header_node(attr_file, clump_size, buf, node_size);
219 mapping = attr_file->i_mapping;
223 for (; written < node_size; index++, written += PAGE_CACHE_SIZE) {
226 page = read_mapping_page(mapping, index, NULL);
229 goto failed_header_node_init;
232 kaddr = kmap_atomic(page);
233 memcpy(kaddr, buf + written,
234 min_t(size_t, PAGE_CACHE_SIZE, node_size - written));
235 kunmap_atomic(kaddr);
237 set_page_dirty(page);
238 page_cache_release(page);
241 hfsplus_mark_inode_dirty(attr_file, HFSPLUS_I_ATTR_DIRTY);
243 sbi->attr_tree = hfs_btree_open(sb, HFSPLUS_ATTR_CNID);
245 pr_err("failed to load attributes file\n");
247 failed_header_node_init:
250 end_attr_file_creation:
254 atomic_set(&sbi->attr_tree_state, HFSPLUS_VALID_ATTR_TREE);
255 else if (err == -ENOSPC)
256 atomic_set(&sbi->attr_tree_state, HFSPLUS_EMPTY_ATTR_TREE);
258 atomic_set(&sbi->attr_tree_state, HFSPLUS_FAILED_ATTR_TREE);
263 int __hfsplus_setxattr(struct inode *inode, const char *name,
264 const void *value, size_t size, int flags)
267 struct hfs_find_data cat_fd;
268 hfsplus_cat_entry entry;
269 u16 cat_entry_flags, cat_entry_type;
270 u16 folder_finderinfo_len = sizeof(struct DInfo) +
271 sizeof(struct DXInfo);
272 u16 file_finderinfo_len = sizeof(struct FInfo) +
273 sizeof(struct FXInfo);
275 if ((!S_ISREG(inode->i_mode) &&
276 !S_ISDIR(inode->i_mode)) ||
277 HFSPLUS_IS_RSRC(inode))
281 return hfsplus_removexattr(inode, name);
283 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
285 pr_err("can't init xattr find struct\n");
289 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
291 pr_err("catalog searching failed\n");
295 if (!strcmp_xattr_finder_info(name)) {
296 if (flags & XATTR_CREATE) {
297 pr_err("xattr exists yet\n");
301 hfs_bnode_read(cat_fd.bnode, &entry, cat_fd.entryoffset,
302 sizeof(hfsplus_cat_entry));
303 if (be16_to_cpu(entry.type) == HFSPLUS_FOLDER) {
304 if (size == folder_finderinfo_len) {
305 memcpy(&entry.folder.user_info, value,
306 folder_finderinfo_len);
307 hfs_bnode_write(cat_fd.bnode, &entry,
309 sizeof(struct hfsplus_cat_folder));
310 hfsplus_mark_inode_dirty(inode,
311 HFSPLUS_I_CAT_DIRTY);
316 } else if (be16_to_cpu(entry.type) == HFSPLUS_FILE) {
317 if (size == file_finderinfo_len) {
318 memcpy(&entry.file.user_info, value,
319 file_finderinfo_len);
320 hfs_bnode_write(cat_fd.bnode, &entry,
322 sizeof(struct hfsplus_cat_file));
323 hfsplus_mark_inode_dirty(inode,
324 HFSPLUS_I_CAT_DIRTY);
336 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) {
337 err = hfsplus_create_attributes_file(inode->i_sb);
342 if (hfsplus_attr_exists(inode, name)) {
343 if (flags & XATTR_CREATE) {
344 pr_err("xattr exists yet\n");
348 err = hfsplus_delete_attr(inode, name);
351 err = hfsplus_create_attr(inode, name, value, size);
355 if (flags & XATTR_REPLACE) {
356 pr_err("cannot replace xattr\n");
360 err = hfsplus_create_attr(inode, name, value, size);
365 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
366 if (cat_entry_type == HFSPLUS_FOLDER) {
367 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
369 offsetof(struct hfsplus_cat_folder, flags));
370 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
371 if (!strcmp_xattr_acl(name))
372 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
373 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
374 offsetof(struct hfsplus_cat_folder, flags),
376 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
377 } else if (cat_entry_type == HFSPLUS_FILE) {
378 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
380 offsetof(struct hfsplus_cat_file, flags));
381 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
382 if (!strcmp_xattr_acl(name))
383 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
384 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
385 offsetof(struct hfsplus_cat_file, flags),
387 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
389 pr_err("invalid catalog entry type\n");
395 hfs_find_exit(&cat_fd);
399 static int name_len(const char *xattr_name, int xattr_name_len)
401 int len = xattr_name_len + 1;
403 if (!is_known_namespace(xattr_name))
404 len += XATTR_MAC_OSX_PREFIX_LEN;
409 static int copy_name(char *buffer, const char *xattr_name, int name_len)
414 if (!is_known_namespace(xattr_name)) {
415 strncpy(buffer, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN);
416 offset += XATTR_MAC_OSX_PREFIX_LEN;
417 len += XATTR_MAC_OSX_PREFIX_LEN;
420 strncpy(buffer + offset, xattr_name, name_len);
421 memset(buffer + offset + name_len, 0, 1);
427 static ssize_t hfsplus_getxattr_finder_info(struct inode *inode,
428 void *value, size_t size)
431 struct hfs_find_data fd;
433 u16 folder_rec_len = sizeof(struct DInfo) + sizeof(struct DXInfo);
434 u16 file_rec_len = sizeof(struct FInfo) + sizeof(struct FXInfo);
435 u16 record_len = max(folder_rec_len, file_rec_len);
436 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
437 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
439 if (size >= record_len) {
440 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
442 pr_err("can't init xattr find struct\n");
445 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
447 goto end_getxattr_finder_info;
448 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
450 if (entry_type == HFSPLUS_FOLDER) {
451 hfs_bnode_read(fd.bnode, folder_finder_info,
453 offsetof(struct hfsplus_cat_folder, user_info),
455 memcpy(value, folder_finder_info, folder_rec_len);
456 res = folder_rec_len;
457 } else if (entry_type == HFSPLUS_FILE) {
458 hfs_bnode_read(fd.bnode, file_finder_info,
460 offsetof(struct hfsplus_cat_file, user_info),
462 memcpy(value, file_finder_info, file_rec_len);
466 goto end_getxattr_finder_info;
469 res = size ? -ERANGE : record_len;
471 end_getxattr_finder_info:
472 if (size >= record_len)
477 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
478 void *value, size_t size)
480 struct hfs_find_data fd;
481 hfsplus_attr_entry *entry;
482 __be32 xattr_record_type;
484 u16 record_length = 0;
487 if ((!S_ISREG(inode->i_mode) &&
488 !S_ISDIR(inode->i_mode)) ||
489 HFSPLUS_IS_RSRC(inode))
492 if (!strcmp_xattr_finder_info(name))
493 return hfsplus_getxattr_finder_info(inode, value, size);
495 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
498 entry = hfsplus_alloc_attr_entry();
500 pr_err("can't allocate xattr entry\n");
504 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
506 pr_err("can't init xattr find struct\n");
507 goto failed_getxattr_init;
510 res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd);
515 pr_err("xattr searching failed\n");
519 hfs_bnode_read(fd.bnode, &xattr_record_type,
520 fd.entryoffset, sizeof(xattr_record_type));
521 record_type = be32_to_cpu(xattr_record_type);
522 if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
523 record_length = hfs_bnode_read_u16(fd.bnode,
525 offsetof(struct hfsplus_attr_inline_data,
527 if (record_length > HFSPLUS_MAX_INLINE_DATA_SIZE) {
528 pr_err("invalid xattr record size\n");
532 } else if (record_type == HFSPLUS_ATTR_FORK_DATA ||
533 record_type == HFSPLUS_ATTR_EXTENTS) {
534 pr_err("only inline data xattr are supported\n");
538 pr_err("invalid xattr record\n");
544 hfs_bnode_read(fd.bnode, entry, fd.entryoffset,
545 offsetof(struct hfsplus_attr_inline_data,
546 raw_bytes) + record_length);
549 if (size >= record_length) {
550 memcpy(value, entry->inline_data.raw_bytes, record_length);
553 res = size ? -ERANGE : record_length;
558 failed_getxattr_init:
559 hfsplus_destroy_attr_entry(entry);
563 static inline int can_list(const char *xattr_name)
568 return strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
569 XATTR_TRUSTED_PREFIX_LEN) ||
570 capable(CAP_SYS_ADMIN);
573 static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
574 char *buffer, size_t size)
577 struct inode *inode = dentry->d_inode;
578 struct hfs_find_data fd;
580 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
581 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
582 unsigned long len, found_bit;
583 int xattr_name_len, symbols_count;
585 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
587 pr_err("can't init xattr find struct\n");
591 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
593 goto end_listxattr_finder_info;
595 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
596 if (entry_type == HFSPLUS_FOLDER) {
597 len = sizeof(struct DInfo) + sizeof(struct DXInfo);
598 hfs_bnode_read(fd.bnode, folder_finder_info,
600 offsetof(struct hfsplus_cat_folder, user_info),
602 found_bit = find_first_bit((void *)folder_finder_info, len*8);
603 } else if (entry_type == HFSPLUS_FILE) {
604 len = sizeof(struct FInfo) + sizeof(struct FXInfo);
605 hfs_bnode_read(fd.bnode, file_finder_info,
607 offsetof(struct hfsplus_cat_file, user_info),
609 found_bit = find_first_bit((void *)file_finder_info, len*8);
612 goto end_listxattr_finder_info;
615 if (found_bit >= (len*8))
618 symbols_count = sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME) - 1;
620 name_len(HFSPLUS_XATTR_FINDER_INFO_NAME, symbols_count);
621 if (!buffer || !size) {
622 if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME))
623 res = xattr_name_len;
624 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) {
625 if (size < xattr_name_len)
628 res = copy_name(buffer,
629 HFSPLUS_XATTR_FINDER_INFO_NAME,
635 end_listxattr_finder_info:
641 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
645 struct inode *inode = dentry->d_inode;
646 struct hfs_find_data fd;
648 struct hfsplus_attr_key attr_key;
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 strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN +
670 XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
676 err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
678 if (err == -ENOENT) {
689 key_len = hfs_bnode_read_u16(fd.bnode, fd.keyoffset);
690 if (key_len == 0 || key_len > fd.tree->max_key_len) {
691 pr_err("invalid xattr key length: %d\n", key_len);
696 hfs_bnode_read(fd.bnode, &attr_key,
697 fd.keyoffset, key_len + sizeof(key_len));
699 if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
702 xattr_name_len = NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN;
703 if (hfsplus_uni2asc(inode->i_sb,
704 (const struct hfsplus_unistr *)&fd.key->attr.key_name,
705 strbuf, &xattr_name_len)) {
706 pr_err("unicode conversion failed\n");
711 if (!buffer || !size) {
712 if (can_list(strbuf))
713 res += name_len(strbuf, xattr_name_len);
714 } else if (can_list(strbuf)) {
715 if (size < (res + name_len(strbuf, xattr_name_len))) {
719 res += copy_name(buffer + res,
720 strbuf, xattr_name_len);
723 if (hfs_brec_goto(&fd, 1))
734 static int hfsplus_removexattr(struct inode *inode, const char *name)
737 struct hfs_find_data cat_fd;
740 int is_xattr_acl_deleted = 0;
741 int is_all_xattrs_deleted = 0;
743 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
746 if (!strcmp_xattr_finder_info(name))
749 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
751 pr_err("can't init xattr find struct\n");
755 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
757 pr_err("catalog searching failed\n");
758 goto end_removexattr;
761 err = hfsplus_delete_attr(inode, name);
763 goto end_removexattr;
765 is_xattr_acl_deleted = !strcmp_xattr_acl(name);
766 is_all_xattrs_deleted = !hfsplus_attr_exists(inode, NULL);
768 if (!is_xattr_acl_deleted && !is_all_xattrs_deleted)
769 goto end_removexattr;
771 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
773 if (cat_entry_type == HFSPLUS_FOLDER) {
774 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
775 offsetof(struct hfsplus_cat_folder, flags));
776 if (is_xattr_acl_deleted)
777 flags &= ~HFSPLUS_ACL_EXISTS;
778 if (is_all_xattrs_deleted)
779 flags &= ~HFSPLUS_XATTR_EXISTS;
780 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
781 offsetof(struct hfsplus_cat_folder, flags),
783 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
784 } else if (cat_entry_type == HFSPLUS_FILE) {
785 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
786 offsetof(struct hfsplus_cat_file, flags));
787 if (is_xattr_acl_deleted)
788 flags &= ~HFSPLUS_ACL_EXISTS;
789 if (is_all_xattrs_deleted)
790 flags &= ~HFSPLUS_XATTR_EXISTS;
791 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
792 offsetof(struct hfsplus_cat_file, flags),
794 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
796 pr_err("invalid catalog entry type\n");
798 goto end_removexattr;
802 hfs_find_exit(&cat_fd);
806 static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name,
807 void *buffer, size_t size, int type)
809 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
810 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
811 size_t len = strlen(name);
813 if (!strcmp(name, ""))
816 if (len > HFSPLUS_ATTR_MAX_STRLEN)
820 * Don't allow retrieving properly prefixed attributes
821 * by prepending them with "osx."
823 if (is_known_namespace(name))
826 return hfsplus_getxattr(dentry, xattr_name, buffer, size);
829 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
830 const void *buffer, size_t size, int flags, int type)
832 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
833 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
834 size_t len = strlen(name);
836 if (!strcmp(name, ""))
839 if (len > HFSPLUS_ATTR_MAX_STRLEN)
843 * Don't allow setting properly prefixed attributes
844 * by prepending them with "osx."
846 if (is_known_namespace(name))
849 return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
852 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,
853 size_t list_size, const char *name, size_t name_len, int type)
856 * This method is not used.
857 * It is used hfsplus_listxattr() instead of generic_listxattr().
862 const struct xattr_handler hfsplus_xattr_osx_handler = {
863 .prefix = XATTR_MAC_OSX_PREFIX,
864 .list = hfsplus_osx_listxattr,
865 .get = hfsplus_osx_getxattr,
866 .set = hfsplus_osx_setxattr,