2 * linux/fs/hfsplus/xattr.c
4 * Vyacheslav Dubeyko <slava@dubeyko.com>
6 * Logic of processing extended attributes
9 #include "hfsplus_fs.h"
13 const struct xattr_handler
*hfsplus_xattr_handlers
[] = {
14 &hfsplus_xattr_osx_handler
,
15 &hfsplus_xattr_user_handler
,
16 &hfsplus_xattr_trusted_handler
,
17 #ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
18 &hfsplus_xattr_acl_access_handler
,
19 &hfsplus_xattr_acl_default_handler
,
21 &hfsplus_xattr_security_handler
,
25 static int strcmp_xattr_finder_info(const char *name
)
28 return strncmp(name
, HFSPLUS_XATTR_FINDER_INFO_NAME
,
29 sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME
));
34 static int strcmp_xattr_acl(const char *name
)
37 return strncmp(name
, HFSPLUS_XATTR_ACL_NAME
,
38 sizeof(HFSPLUS_XATTR_ACL_NAME
));
43 static inline int is_known_namespace(const char *name
)
45 if (strncmp(name
, XATTR_SYSTEM_PREFIX
, XATTR_SYSTEM_PREFIX_LEN
) &&
46 strncmp(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
) &&
47 strncmp(name
, XATTR_SECURITY_PREFIX
, XATTR_SECURITY_PREFIX_LEN
) &&
48 strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
))
54 static int can_set_system_xattr(struct inode
*inode
, const char *name
,
55 const void *value
, size_t size
)
57 #ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
58 struct posix_acl
*acl
;
61 if (!inode_owner_or_capable(inode
))
65 * POSIX_ACL_XATTR_ACCESS is tied to i_mode
67 if (strcmp(name
, POSIX_ACL_XATTR_ACCESS
) == 0) {
68 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
72 err
= posix_acl_equiv_mode(acl
, &inode
->i_mode
);
73 posix_acl_release(acl
);
76 mark_inode_dirty(inode
);
79 * We're changing the ACL. Get rid of the cached one
81 forget_cached_acl(inode
, ACL_TYPE_ACCESS
);
84 } else if (strcmp(name
, POSIX_ACL_XATTR_DEFAULT
) == 0) {
85 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
88 posix_acl_release(acl
);
91 * We're changing the default ACL. Get rid of the cached one
93 forget_cached_acl(inode
, ACL_TYPE_DEFAULT
);
97 #endif /* CONFIG_HFSPLUS_FS_POSIX_ACL */
101 static int can_set_xattr(struct inode
*inode
, const char *name
,
102 const void *value
, size_t value_len
)
104 if (!strncmp(name
, XATTR_SYSTEM_PREFIX
, XATTR_SYSTEM_PREFIX_LEN
))
105 return can_set_system_xattr(inode
, name
, value
, value_len
);
107 if (!strncmp(name
, XATTR_MAC_OSX_PREFIX
, XATTR_MAC_OSX_PREFIX_LEN
)) {
109 * This makes sure that we aren't trying to set an
110 * attribute in a different namespace by prefixing it
113 if (is_known_namespace(name
+ XATTR_MAC_OSX_PREFIX_LEN
))
120 * Don't allow setting an attribute in an unknown namespace.
122 if (strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
) &&
123 strncmp(name
, XATTR_SECURITY_PREFIX
, XATTR_SECURITY_PREFIX_LEN
) &&
124 strncmp(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
))
130 static void hfsplus_init_header_node(struct inode
*attr_file
,
132 char *buf
, u16 node_size
)
134 struct hfs_bnode_desc
*desc
;
135 struct hfs_btree_header_rec
*head
;
138 u32 hdr_node_map_rec_bits
;
144 hfs_dbg(ATTR_MOD
, "init_hdr_attr_file: clump %u, node_size %u\n",
145 clump_size
, node_size
);
147 /* The end of the node contains list of record offsets */
148 rec_offsets
= (__be16
*)(buf
+ node_size
);
150 desc
= (struct hfs_bnode_desc
*)buf
;
151 desc
->type
= HFS_NODE_HEADER
;
152 desc
->num_recs
= cpu_to_be16(HFSPLUS_BTREE_HDR_NODE_RECS_COUNT
);
153 offset
= sizeof(struct hfs_bnode_desc
);
154 *--rec_offsets
= cpu_to_be16(offset
);
156 head
= (struct hfs_btree_header_rec
*)(buf
+ offset
);
157 head
->node_size
= cpu_to_be16(node_size
);
158 tmp
= i_size_read(attr_file
);
159 do_div(tmp
, node_size
);
160 head
->node_count
= cpu_to_be32(tmp
);
161 head
->free_nodes
= cpu_to_be32(be32_to_cpu(head
->node_count
) - 1);
162 head
->clump_size
= cpu_to_be32(clump_size
);
163 head
->attributes
|= cpu_to_be32(HFS_TREE_BIGKEYS
| HFS_TREE_VARIDXKEYS
);
164 head
->max_key_len
= cpu_to_be16(HFSPLUS_ATTR_KEYLEN
- sizeof(u16
));
165 offset
+= sizeof(struct hfs_btree_header_rec
);
166 *--rec_offsets
= cpu_to_be16(offset
);
167 offset
+= HFSPLUS_BTREE_HDR_USER_BYTES
;
168 *--rec_offsets
= cpu_to_be16(offset
);
170 hdr_node_map_rec_bits
= 8 * (node_size
- offset
- (4 * sizeof(u16
)));
171 if (be32_to_cpu(head
->node_count
) > hdr_node_map_rec_bits
) {
175 desc
->next
= cpu_to_be32(be32_to_cpu(head
->leaf_tail
) + 1);
176 map_node_bits
= 8 * (node_size
- sizeof(struct hfs_bnode_desc
) -
177 (2 * sizeof(u16
)) - 2);
178 map_nodes
= (be32_to_cpu(head
->node_count
) -
179 hdr_node_map_rec_bits
+
180 (map_node_bits
- 1)) / map_node_bits
;
181 be32_add_cpu(&head
->free_nodes
, 0 - map_nodes
);
186 be32_to_cpu(head
->node_count
) - be32_to_cpu(head
->free_nodes
);
187 used_bmp_bytes
= used_nodes
/ 8;
188 if (used_bmp_bytes
) {
189 memset(bmp
, 0xFF, used_bmp_bytes
);
190 bmp
+= used_bmp_bytes
;
193 *bmp
= ~(0xFF >> used_nodes
);
194 offset
+= hdr_node_map_rec_bits
/ 8;
195 *--rec_offsets
= cpu_to_be16(offset
);
198 static int hfsplus_create_attributes_file(struct super_block
*sb
)
201 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
202 struct inode
*attr_file
;
203 struct hfsplus_inode_info
*hip
;
205 u16 node_size
= HFSPLUS_ATTR_TREE_NODE_SIZE
;
208 struct address_space
*mapping
;
210 int old_state
= HFSPLUS_EMPTY_ATTR_TREE
;
212 hfs_dbg(ATTR_MOD
, "create_attr_file: ino %d\n", HFSPLUS_ATTR_CNID
);
214 check_attr_tree_state_again
:
215 switch (atomic_read(&sbi
->attr_tree_state
)) {
216 case HFSPLUS_EMPTY_ATTR_TREE
:
217 if (old_state
!= atomic_cmpxchg(&sbi
->attr_tree_state
,
219 HFSPLUS_CREATING_ATTR_TREE
))
220 goto check_attr_tree_state_again
;
222 case HFSPLUS_CREATING_ATTR_TREE
:
224 * This state means that another thread is in process
225 * of AttributesFile creation. Theoretically, it is
226 * possible to be here. But really __setxattr() method
227 * first of all calls hfs_find_init() for lookup in
228 * B-tree of CatalogFile. This method locks mutex of
229 * CatalogFile's B-tree. As a result, if some thread
230 * is inside AttributedFile creation operation then
231 * another threads will be waiting unlocking of
232 * CatalogFile's B-tree's mutex. However, if code will
233 * change then we will return error code (-EAGAIN) from
234 * here. Really, it means that first try to set of xattr
235 * fails with error but second attempt will have success.
238 case HFSPLUS_VALID_ATTR_TREE
:
240 case HFSPLUS_FAILED_ATTR_TREE
:
246 attr_file
= hfsplus_iget(sb
, HFSPLUS_ATTR_CNID
);
247 if (IS_ERR(attr_file
)) {
248 pr_err("failed to load attributes file\n");
249 return PTR_ERR(attr_file
);
252 BUG_ON(i_size_read(attr_file
) != 0);
254 hip
= HFSPLUS_I(attr_file
);
256 clump_size
= hfsplus_calc_btree_clump_size(sb
->s_blocksize
,
261 mutex_lock(&hip
->extents_lock
);
262 hip
->clump_blocks
= clump_size
>> sbi
->alloc_blksz_shift
;
263 mutex_unlock(&hip
->extents_lock
);
265 if (sbi
->free_blocks
<= (hip
->clump_blocks
<< 1)) {
267 goto end_attr_file_creation
;
270 while (hip
->alloc_blocks
< hip
->clump_blocks
) {
271 err
= hfsplus_file_extend(attr_file
);
273 pr_err("failed to extend attributes file\n");
274 goto end_attr_file_creation
;
276 hip
->phys_size
= attr_file
->i_size
=
277 (loff_t
)hip
->alloc_blocks
<< sbi
->alloc_blksz_shift
;
278 hip
->fs_blocks
= hip
->alloc_blocks
<< sbi
->fs_shift
;
279 inode_set_bytes(attr_file
, attr_file
->i_size
);
282 buf
= kzalloc(node_size
, GFP_NOFS
);
284 pr_err("failed to allocate memory for header node\n");
286 goto end_attr_file_creation
;
289 hfsplus_init_header_node(attr_file
, clump_size
, buf
, node_size
);
291 mapping
= attr_file
->i_mapping
;
295 for (; written
< node_size
; index
++, written
+= PAGE_CACHE_SIZE
) {
298 page
= read_mapping_page(mapping
, index
, NULL
);
301 goto failed_header_node_init
;
304 kaddr
= kmap_atomic(page
);
305 memcpy(kaddr
, buf
+ written
,
306 min_t(size_t, PAGE_CACHE_SIZE
, node_size
- written
));
307 kunmap_atomic(kaddr
);
309 set_page_dirty(page
);
310 page_cache_release(page
);
313 hfsplus_mark_inode_dirty(attr_file
, HFSPLUS_I_ATTR_DIRTY
);
315 sbi
->attr_tree
= hfs_btree_open(sb
, HFSPLUS_ATTR_CNID
);
317 pr_err("failed to load attributes file\n");
319 failed_header_node_init
:
322 end_attr_file_creation
:
326 atomic_set(&sbi
->attr_tree_state
, HFSPLUS_VALID_ATTR_TREE
);
327 else if (err
== -ENOSPC
)
328 atomic_set(&sbi
->attr_tree_state
, HFSPLUS_EMPTY_ATTR_TREE
);
330 atomic_set(&sbi
->attr_tree_state
, HFSPLUS_FAILED_ATTR_TREE
);
335 int __hfsplus_setxattr(struct inode
*inode
, const char *name
,
336 const void *value
, size_t size
, int flags
)
339 struct hfs_find_data cat_fd
;
340 hfsplus_cat_entry entry
;
341 u16 cat_entry_flags
, cat_entry_type
;
342 u16 folder_finderinfo_len
= sizeof(struct DInfo
) +
343 sizeof(struct DXInfo
);
344 u16 file_finderinfo_len
= sizeof(struct FInfo
) +
345 sizeof(struct FXInfo
);
347 if ((!S_ISREG(inode
->i_mode
) &&
348 !S_ISDIR(inode
->i_mode
)) ||
349 HFSPLUS_IS_RSRC(inode
))
352 err
= can_set_xattr(inode
, name
, value
, size
);
356 if (strncmp(name
, XATTR_MAC_OSX_PREFIX
,
357 XATTR_MAC_OSX_PREFIX_LEN
) == 0)
358 name
+= XATTR_MAC_OSX_PREFIX_LEN
;
365 err
= hfs_find_init(HFSPLUS_SB(inode
->i_sb
)->cat_tree
, &cat_fd
);
367 pr_err("can't init xattr find struct\n");
371 err
= hfsplus_find_cat(inode
->i_sb
, inode
->i_ino
, &cat_fd
);
373 pr_err("catalog searching failed\n");
377 if (!strcmp_xattr_finder_info(name
)) {
378 if (flags
& XATTR_CREATE
) {
379 pr_err("xattr exists yet\n");
383 hfs_bnode_read(cat_fd
.bnode
, &entry
, cat_fd
.entryoffset
,
384 sizeof(hfsplus_cat_entry
));
385 if (be16_to_cpu(entry
.type
) == HFSPLUS_FOLDER
) {
386 if (size
== folder_finderinfo_len
) {
387 memcpy(&entry
.folder
.user_info
, value
,
388 folder_finderinfo_len
);
389 hfs_bnode_write(cat_fd
.bnode
, &entry
,
391 sizeof(struct hfsplus_cat_folder
));
392 hfsplus_mark_inode_dirty(inode
,
393 HFSPLUS_I_CAT_DIRTY
);
398 } else if (be16_to_cpu(entry
.type
) == HFSPLUS_FILE
) {
399 if (size
== file_finderinfo_len
) {
400 memcpy(&entry
.file
.user_info
, value
,
401 file_finderinfo_len
);
402 hfs_bnode_write(cat_fd
.bnode
, &entry
,
404 sizeof(struct hfsplus_cat_file
));
405 hfsplus_mark_inode_dirty(inode
,
406 HFSPLUS_I_CAT_DIRTY
);
418 if (!HFSPLUS_SB(inode
->i_sb
)->attr_tree
) {
419 err
= hfsplus_create_attributes_file(inode
->i_sb
);
424 if (hfsplus_attr_exists(inode
, name
)) {
425 if (flags
& XATTR_CREATE
) {
426 pr_err("xattr exists yet\n");
430 err
= hfsplus_delete_attr(inode
, name
);
433 err
= hfsplus_create_attr(inode
, name
, value
, size
);
437 if (flags
& XATTR_REPLACE
) {
438 pr_err("cannot replace xattr\n");
442 err
= hfsplus_create_attr(inode
, name
, value
, size
);
447 cat_entry_type
= hfs_bnode_read_u16(cat_fd
.bnode
, cat_fd
.entryoffset
);
448 if (cat_entry_type
== HFSPLUS_FOLDER
) {
449 cat_entry_flags
= hfs_bnode_read_u16(cat_fd
.bnode
,
451 offsetof(struct hfsplus_cat_folder
, flags
));
452 cat_entry_flags
|= HFSPLUS_XATTR_EXISTS
;
453 if (!strcmp_xattr_acl(name
))
454 cat_entry_flags
|= HFSPLUS_ACL_EXISTS
;
455 hfs_bnode_write_u16(cat_fd
.bnode
, cat_fd
.entryoffset
+
456 offsetof(struct hfsplus_cat_folder
, flags
),
458 hfsplus_mark_inode_dirty(inode
, HFSPLUS_I_CAT_DIRTY
);
459 } else if (cat_entry_type
== HFSPLUS_FILE
) {
460 cat_entry_flags
= hfs_bnode_read_u16(cat_fd
.bnode
,
462 offsetof(struct hfsplus_cat_file
, flags
));
463 cat_entry_flags
|= HFSPLUS_XATTR_EXISTS
;
464 if (!strcmp_xattr_acl(name
))
465 cat_entry_flags
|= HFSPLUS_ACL_EXISTS
;
466 hfs_bnode_write_u16(cat_fd
.bnode
, cat_fd
.entryoffset
+
467 offsetof(struct hfsplus_cat_file
, flags
),
469 hfsplus_mark_inode_dirty(inode
, HFSPLUS_I_CAT_DIRTY
);
471 pr_err("invalid catalog entry type\n");
477 hfs_find_exit(&cat_fd
);
481 static inline int is_osx_xattr(const char *xattr_name
)
483 return !is_known_namespace(xattr_name
);
486 static int name_len(const char *xattr_name
, int xattr_name_len
)
488 int len
= xattr_name_len
+ 1;
490 if (is_osx_xattr(xattr_name
))
491 len
+= XATTR_MAC_OSX_PREFIX_LEN
;
496 static int copy_name(char *buffer
, const char *xattr_name
, int name_len
)
501 if (is_osx_xattr(xattr_name
)) {
502 strncpy(buffer
, XATTR_MAC_OSX_PREFIX
, XATTR_MAC_OSX_PREFIX_LEN
);
503 offset
+= XATTR_MAC_OSX_PREFIX_LEN
;
504 len
+= XATTR_MAC_OSX_PREFIX_LEN
;
507 strncpy(buffer
+ offset
, xattr_name
, name_len
);
508 memset(buffer
+ offset
+ name_len
, 0, 1);
514 static ssize_t
hfsplus_getxattr_finder_info(struct inode
*inode
,
515 void *value
, size_t size
)
518 struct hfs_find_data fd
;
520 u16 folder_rec_len
= sizeof(struct DInfo
) + sizeof(struct DXInfo
);
521 u16 file_rec_len
= sizeof(struct FInfo
) + sizeof(struct FXInfo
);
522 u16 record_len
= max(folder_rec_len
, file_rec_len
);
523 u8 folder_finder_info
[sizeof(struct DInfo
) + sizeof(struct DXInfo
)];
524 u8 file_finder_info
[sizeof(struct FInfo
) + sizeof(struct FXInfo
)];
526 if (size
>= record_len
) {
527 res
= hfs_find_init(HFSPLUS_SB(inode
->i_sb
)->cat_tree
, &fd
);
529 pr_err("can't init xattr find struct\n");
532 res
= hfsplus_find_cat(inode
->i_sb
, inode
->i_ino
, &fd
);
534 goto end_getxattr_finder_info
;
535 entry_type
= hfs_bnode_read_u16(fd
.bnode
, fd
.entryoffset
);
537 if (entry_type
== HFSPLUS_FOLDER
) {
538 hfs_bnode_read(fd
.bnode
, folder_finder_info
,
540 offsetof(struct hfsplus_cat_folder
, user_info
),
542 memcpy(value
, folder_finder_info
, folder_rec_len
);
543 res
= folder_rec_len
;
544 } else if (entry_type
== HFSPLUS_FILE
) {
545 hfs_bnode_read(fd
.bnode
, file_finder_info
,
547 offsetof(struct hfsplus_cat_file
, user_info
),
549 memcpy(value
, file_finder_info
, file_rec_len
);
553 goto end_getxattr_finder_info
;
556 res
= size
? -ERANGE
: record_len
;
558 end_getxattr_finder_info
:
559 if (size
>= record_len
)
564 ssize_t
__hfsplus_getxattr(struct inode
*inode
, const char *name
,
565 void *value
, size_t size
)
567 struct hfs_find_data fd
;
568 hfsplus_attr_entry
*entry
;
569 __be32 xattr_record_type
;
571 u16 record_length
= 0;
574 if ((!S_ISREG(inode
->i_mode
) &&
575 !S_ISDIR(inode
->i_mode
)) ||
576 HFSPLUS_IS_RSRC(inode
))
579 if (strncmp(name
, XATTR_MAC_OSX_PREFIX
,
580 XATTR_MAC_OSX_PREFIX_LEN
) == 0) {
581 /* skip "osx." prefix */
582 name
+= XATTR_MAC_OSX_PREFIX_LEN
;
584 * Don't allow retrieving properly prefixed attributes
585 * by prepending them with "osx."
587 if (is_known_namespace(name
))
591 if (!strcmp_xattr_finder_info(name
))
592 return hfsplus_getxattr_finder_info(inode
, value
, size
);
594 if (!HFSPLUS_SB(inode
->i_sb
)->attr_tree
)
597 entry
= hfsplus_alloc_attr_entry();
599 pr_err("can't allocate xattr entry\n");
603 res
= hfs_find_init(HFSPLUS_SB(inode
->i_sb
)->attr_tree
, &fd
);
605 pr_err("can't init xattr find struct\n");
606 goto failed_getxattr_init
;
609 res
= hfsplus_find_attr(inode
->i_sb
, inode
->i_ino
, name
, &fd
);
614 pr_err("xattr searching failed\n");
618 hfs_bnode_read(fd
.bnode
, &xattr_record_type
,
619 fd
.entryoffset
, sizeof(xattr_record_type
));
620 record_type
= be32_to_cpu(xattr_record_type
);
621 if (record_type
== HFSPLUS_ATTR_INLINE_DATA
) {
622 record_length
= hfs_bnode_read_u16(fd
.bnode
,
624 offsetof(struct hfsplus_attr_inline_data
,
626 if (record_length
> HFSPLUS_MAX_INLINE_DATA_SIZE
) {
627 pr_err("invalid xattr record size\n");
631 } else if (record_type
== HFSPLUS_ATTR_FORK_DATA
||
632 record_type
== HFSPLUS_ATTR_EXTENTS
) {
633 pr_err("only inline data xattr are supported\n");
637 pr_err("invalid xattr record\n");
643 hfs_bnode_read(fd
.bnode
, entry
, fd
.entryoffset
,
644 offsetof(struct hfsplus_attr_inline_data
,
645 raw_bytes
) + record_length
);
648 if (size
>= record_length
) {
649 memcpy(value
, entry
->inline_data
.raw_bytes
, record_length
);
652 res
= size
? -ERANGE
: record_length
;
657 failed_getxattr_init
:
658 hfsplus_destroy_attr_entry(entry
);
662 static inline int can_list(const char *xattr_name
)
667 return strncmp(xattr_name
, XATTR_TRUSTED_PREFIX
,
668 XATTR_TRUSTED_PREFIX_LEN
) ||
669 capable(CAP_SYS_ADMIN
);
672 static ssize_t
hfsplus_listxattr_finder_info(struct dentry
*dentry
,
673 char *buffer
, size_t size
)
676 struct inode
*inode
= dentry
->d_inode
;
677 struct hfs_find_data fd
;
679 u8 folder_finder_info
[sizeof(struct DInfo
) + sizeof(struct DXInfo
)];
680 u8 file_finder_info
[sizeof(struct FInfo
) + sizeof(struct FXInfo
)];
681 unsigned long len
, found_bit
;
682 int xattr_name_len
, symbols_count
;
684 res
= hfs_find_init(HFSPLUS_SB(inode
->i_sb
)->cat_tree
, &fd
);
686 pr_err("can't init xattr find struct\n");
690 res
= hfsplus_find_cat(inode
->i_sb
, inode
->i_ino
, &fd
);
692 goto end_listxattr_finder_info
;
694 entry_type
= hfs_bnode_read_u16(fd
.bnode
, fd
.entryoffset
);
695 if (entry_type
== HFSPLUS_FOLDER
) {
696 len
= sizeof(struct DInfo
) + sizeof(struct DXInfo
);
697 hfs_bnode_read(fd
.bnode
, folder_finder_info
,
699 offsetof(struct hfsplus_cat_folder
, user_info
),
701 found_bit
= find_first_bit((void *)folder_finder_info
, len
*8);
702 } else if (entry_type
== HFSPLUS_FILE
) {
703 len
= sizeof(struct FInfo
) + sizeof(struct FXInfo
);
704 hfs_bnode_read(fd
.bnode
, file_finder_info
,
706 offsetof(struct hfsplus_cat_file
, user_info
),
708 found_bit
= find_first_bit((void *)file_finder_info
, len
*8);
711 goto end_listxattr_finder_info
;
714 if (found_bit
>= (len
*8))
717 symbols_count
= sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME
) - 1;
719 name_len(HFSPLUS_XATTR_FINDER_INFO_NAME
, symbols_count
);
720 if (!buffer
|| !size
) {
721 if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME
))
722 res
= xattr_name_len
;
723 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME
)) {
724 if (size
< xattr_name_len
)
727 res
= copy_name(buffer
,
728 HFSPLUS_XATTR_FINDER_INFO_NAME
,
734 end_listxattr_finder_info
:
740 ssize_t
hfsplus_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
744 struct inode
*inode
= dentry
->d_inode
;
745 struct hfs_find_data fd
;
747 struct hfsplus_attr_key attr_key
;
748 char strbuf
[HFSPLUS_ATTR_MAX_STRLEN
+
749 XATTR_MAC_OSX_PREFIX_LEN
+ 1] = {0};
752 if ((!S_ISREG(inode
->i_mode
) &&
753 !S_ISDIR(inode
->i_mode
)) ||
754 HFSPLUS_IS_RSRC(inode
))
757 res
= hfsplus_listxattr_finder_info(dentry
, buffer
, size
);
760 else if (!HFSPLUS_SB(inode
->i_sb
)->attr_tree
)
761 return (res
== 0) ? -EOPNOTSUPP
: res
;
763 err
= hfs_find_init(HFSPLUS_SB(inode
->i_sb
)->attr_tree
, &fd
);
765 pr_err("can't init xattr find struct\n");
769 err
= hfsplus_find_attr(inode
->i_sb
, inode
->i_ino
, NULL
, &fd
);
771 if (err
== -ENOENT
) {
782 key_len
= hfs_bnode_read_u16(fd
.bnode
, fd
.keyoffset
);
783 if (key_len
== 0 || key_len
> fd
.tree
->max_key_len
) {
784 pr_err("invalid xattr key length: %d\n", key_len
);
789 hfs_bnode_read(fd
.bnode
, &attr_key
,
790 fd
.keyoffset
, key_len
+ sizeof(key_len
));
792 if (be32_to_cpu(attr_key
.cnid
) != inode
->i_ino
)
795 xattr_name_len
= HFSPLUS_ATTR_MAX_STRLEN
;
796 if (hfsplus_uni2asc(inode
->i_sb
,
797 (const struct hfsplus_unistr
*)&fd
.key
->attr
.key_name
,
798 strbuf
, &xattr_name_len
)) {
799 pr_err("unicode conversion failed\n");
804 if (!buffer
|| !size
) {
805 if (can_list(strbuf
))
806 res
+= name_len(strbuf
, xattr_name_len
);
807 } else if (can_list(strbuf
)) {
808 if (size
< (res
+ name_len(strbuf
, xattr_name_len
))) {
812 res
+= copy_name(buffer
+ res
,
813 strbuf
, xattr_name_len
);
816 if (hfs_brec_goto(&fd
, 1))
825 int hfsplus_removexattr(struct dentry
*dentry
, const char *name
)
828 struct inode
*inode
= dentry
->d_inode
;
829 struct hfs_find_data cat_fd
;
832 int is_xattr_acl_deleted
= 0;
833 int is_all_xattrs_deleted
= 0;
835 if ((!S_ISREG(inode
->i_mode
) &&
836 !S_ISDIR(inode
->i_mode
)) ||
837 HFSPLUS_IS_RSRC(inode
))
840 if (!HFSPLUS_SB(inode
->i_sb
)->attr_tree
)
843 err
= can_set_xattr(inode
, name
, NULL
, 0);
847 if (strncmp(name
, XATTR_MAC_OSX_PREFIX
,
848 XATTR_MAC_OSX_PREFIX_LEN
) == 0)
849 name
+= XATTR_MAC_OSX_PREFIX_LEN
;
851 if (!strcmp_xattr_finder_info(name
))
854 err
= hfs_find_init(HFSPLUS_SB(inode
->i_sb
)->cat_tree
, &cat_fd
);
856 pr_err("can't init xattr find struct\n");
860 err
= hfsplus_find_cat(inode
->i_sb
, inode
->i_ino
, &cat_fd
);
862 pr_err("catalog searching failed\n");
863 goto end_removexattr
;
866 err
= hfsplus_delete_attr(inode
, name
);
868 goto end_removexattr
;
870 is_xattr_acl_deleted
= !strcmp_xattr_acl(name
);
871 is_all_xattrs_deleted
= !hfsplus_attr_exists(inode
, NULL
);
873 if (!is_xattr_acl_deleted
&& !is_all_xattrs_deleted
)
874 goto end_removexattr
;
876 cat_entry_type
= hfs_bnode_read_u16(cat_fd
.bnode
, cat_fd
.entryoffset
);
878 if (cat_entry_type
== HFSPLUS_FOLDER
) {
879 flags
= hfs_bnode_read_u16(cat_fd
.bnode
, cat_fd
.entryoffset
+
880 offsetof(struct hfsplus_cat_folder
, flags
));
881 if (is_xattr_acl_deleted
)
882 flags
&= ~HFSPLUS_ACL_EXISTS
;
883 if (is_all_xattrs_deleted
)
884 flags
&= ~HFSPLUS_XATTR_EXISTS
;
885 hfs_bnode_write_u16(cat_fd
.bnode
, cat_fd
.entryoffset
+
886 offsetof(struct hfsplus_cat_folder
, flags
),
888 hfsplus_mark_inode_dirty(inode
, HFSPLUS_I_CAT_DIRTY
);
889 } else if (cat_entry_type
== HFSPLUS_FILE
) {
890 flags
= hfs_bnode_read_u16(cat_fd
.bnode
, cat_fd
.entryoffset
+
891 offsetof(struct hfsplus_cat_file
, flags
));
892 if (is_xattr_acl_deleted
)
893 flags
&= ~HFSPLUS_ACL_EXISTS
;
894 if (is_all_xattrs_deleted
)
895 flags
&= ~HFSPLUS_XATTR_EXISTS
;
896 hfs_bnode_write_u16(cat_fd
.bnode
, cat_fd
.entryoffset
+
897 offsetof(struct hfsplus_cat_file
, flags
),
899 hfsplus_mark_inode_dirty(inode
, HFSPLUS_I_CAT_DIRTY
);
901 pr_err("invalid catalog entry type\n");
903 goto end_removexattr
;
907 hfs_find_exit(&cat_fd
);
911 static int hfsplus_osx_getxattr(struct dentry
*dentry
, const char *name
,
912 void *buffer
, size_t size
, int type
)
914 char xattr_name
[HFSPLUS_ATTR_MAX_STRLEN
+
915 XATTR_MAC_OSX_PREFIX_LEN
+ 1] = {0};
916 size_t len
= strlen(name
);
918 if (!strcmp(name
, ""))
921 if (len
> HFSPLUS_ATTR_MAX_STRLEN
)
924 strcpy(xattr_name
, XATTR_MAC_OSX_PREFIX
);
925 strcpy(xattr_name
+ XATTR_MAC_OSX_PREFIX_LEN
, name
);
927 return hfsplus_getxattr(dentry
, xattr_name
, buffer
, size
);
930 static int hfsplus_osx_setxattr(struct dentry
*dentry
, const char *name
,
931 const void *buffer
, size_t size
, int flags
, int type
)
933 char xattr_name
[HFSPLUS_ATTR_MAX_STRLEN
+
934 XATTR_MAC_OSX_PREFIX_LEN
+ 1] = {0};
935 size_t len
= strlen(name
);
937 if (!strcmp(name
, ""))
940 if (len
> HFSPLUS_ATTR_MAX_STRLEN
)
943 strcpy(xattr_name
, XATTR_MAC_OSX_PREFIX
);
944 strcpy(xattr_name
+ XATTR_MAC_OSX_PREFIX_LEN
, name
);
946 return hfsplus_setxattr(dentry
, xattr_name
, buffer
, size
, flags
);
949 static size_t hfsplus_osx_listxattr(struct dentry
*dentry
, char *list
,
950 size_t list_size
, const char *name
, size_t name_len
, int type
)
953 * This method is not used.
954 * It is used hfsplus_listxattr() instead of generic_listxattr().
959 const struct xattr_handler hfsplus_xattr_osx_handler
= {
960 .prefix
= XATTR_MAC_OSX_PREFIX
,
961 .list
= hfsplus_osx_listxattr
,
962 .get
= hfsplus_osx_getxattr
,
963 .set
= hfsplus_osx_setxattr
,