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
,