projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'acpi-ec'
[deliverable/linux.git] / fs / hfsplus / xattr.c
1 /*
2 * linux/fs/hfsplus/xattr.c
3 *
4 * Vyacheslav Dubeyko <slava@dubeyko.com>
5 *
6 * Logic of processing extended attributes
7 */
8
9 #include "hfsplus_fs.h"
10 #include "xattr.h"
11 #include "acl.h"
12
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,
20 #endif
21 &hfsplus_xattr_security_handler,
22 NULL
23 };
24
25 static int strcmp_xattr_finder_info(const char *name)
26 {
27 if (name) {
28 return strncmp(name, HFSPLUS_XATTR_FINDER_INFO_NAME,
29 sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME));
30 }
31 return -1;
32 }
33
34 static int strcmp_xattr_acl(const char *name)
35 {
36 if (name) {
37 return strncmp(name, HFSPLUS_XATTR_ACL_NAME,
38 sizeof(HFSPLUS_XATTR_ACL_NAME));
39 }
40 return -1;
41 }
42
43 static inline int is_known_namespace(const char *name)
44 {
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))
49 return false;
50
51 return true;
52 }
53
54 static int can_set_system_xattr(struct inode *inode, const char *name,
55 const void *value, size_t size)
56 {
57 #ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
58 struct posix_acl *acl;
59 int err;
60
61 if (!inode_owner_or_capable(inode))
62 return -EPERM;
63
64 /*
65 * POSIX_ACL_XATTR_ACCESS is tied to i_mode
66 */
67 if (strcmp(name, POSIX_ACL_XATTR_ACCESS) == 0) {
68 acl = posix_acl_from_xattr(&init_user_ns, value, size);
69 if (IS_ERR(acl))
70 return PTR_ERR(acl);
71 if (acl) {
72 err = posix_acl_equiv_mode(acl, &inode->i_mode);
73 posix_acl_release(acl);
74 if (err < 0)
75 return err;
76 mark_inode_dirty(inode);
77 }
78 /*
79 * We're changing the ACL. Get rid of the cached one
80 */
81 forget_cached_acl(inode, ACL_TYPE_ACCESS);
82
83 return 0;
84 } else if (strcmp(name, POSIX_ACL_XATTR_DEFAULT) == 0) {
85 acl = posix_acl_from_xattr(&init_user_ns, value, size);
86 if (IS_ERR(acl))
87 return PTR_ERR(acl);
88 posix_acl_release(acl);
89
90 /*
91 * We're changing the default ACL. Get rid of the cached one
92 */
93 forget_cached_acl(inode, ACL_TYPE_DEFAULT);
94
95 return 0;
96 }
97 #endif /* CONFIG_HFSPLUS_FS_POSIX_ACL */
98 return -EOPNOTSUPP;
99 }
100
101 static int can_set_xattr(struct inode *inode, const char *name,
102 const void *value, size_t value_len)
103 {
104 if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
105 return can_set_system_xattr(inode, name, value, value_len);
106
107 if (!strncmp(name, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN)) {
108 /*
109 * This makes sure that we aren't trying to set an
110 * attribute in a different namespace by prefixing it
111 * with "osx."
112 */
113 if (is_known_namespace(name + XATTR_MAC_OSX_PREFIX_LEN))
114 return -EOPNOTSUPP;
115
116 return 0;
117 }
118
119 /*
120 * Don't allow setting an attribute in an unknown namespace.
121 */
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))
125 return -EOPNOTSUPP;
126
127 return 0;
128 }
129
130 static void hfsplus_init_header_node(struct inode *attr_file,
131 u32 clump_size,
132 char *buf, size_t node_size)
133 {
134 struct hfs_bnode_desc *desc;
135 struct hfs_btree_header_rec *head;
136 u16 offset;
137 __be16 *rec_offsets;
138 u32 hdr_node_map_rec_bits;
139 char *bmp;
140 u32 used_nodes;
141 u32 used_bmp_bytes;
142
143 hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %zu\n",
144 clump_size, node_size);
145
146 /* The end of the node contains list of record offsets */
147 rec_offsets = (__be16 *)(buf + node_size);
148
149 desc = (struct hfs_bnode_desc *)buf;
150 desc->type = HFS_NODE_HEADER;
151 desc->num_recs = cpu_to_be16(HFSPLUS_BTREE_HDR_NODE_RECS_COUNT);
152 offset = sizeof(struct hfs_bnode_desc);
153 *--rec_offsets = cpu_to_be16(offset);
154
155 head = (struct hfs_btree_header_rec *)(buf + offset);
156 head->node_size = cpu_to_be16(node_size);
157 head->node_count = cpu_to_be32(i_size_read(attr_file) / node_size);
158 head->free_nodes = cpu_to_be32(be32_to_cpu(head->node_count) - 1);
159 head->clump_size = cpu_to_be32(clump_size);
160 head->attributes |= cpu_to_be32(HFS_TREE_BIGKEYS | HFS_TREE_VARIDXKEYS);
161 head->max_key_len = cpu_to_be16(HFSPLUS_ATTR_KEYLEN - sizeof(u16));
162 offset += sizeof(struct hfs_btree_header_rec);
163 *--rec_offsets = cpu_to_be16(offset);
164 offset += HFSPLUS_BTREE_HDR_USER_BYTES;
165 *--rec_offsets = cpu_to_be16(offset);
166
167 hdr_node_map_rec_bits = 8 * (node_size - offset - (4 * sizeof(u16)));
168 if (be32_to_cpu(head->node_count) > hdr_node_map_rec_bits) {
169 u32 map_node_bits;
170 u32 map_nodes;
171
172 desc->next = cpu_to_be32(be32_to_cpu(head->leaf_tail) + 1);
173 map_node_bits = 8 * (node_size - sizeof(struct hfs_bnode_desc) -
174 (2 * sizeof(u16)) - 2);
175 map_nodes = (be32_to_cpu(head->node_count) -
176 hdr_node_map_rec_bits +
177 (map_node_bits - 1)) / map_node_bits;
178 be32_add_cpu(&head->free_nodes, 0 - map_nodes);
179 }
180
181 bmp = buf + offset;
182 used_nodes =
183 be32_to_cpu(head->node_count) - be32_to_cpu(head->free_nodes);
184 used_bmp_bytes = used_nodes / 8;
185 if (used_bmp_bytes) {
186 memset(bmp, 0xFF, used_bmp_bytes);
187 bmp += used_bmp_bytes;
188 used_nodes %= 8;
189 }
190 *bmp = ~(0xFF >> used_nodes);
191 offset += hdr_node_map_rec_bits / 8;
192 *--rec_offsets = cpu_to_be16(offset);
193 }
194
195 static int hfsplus_create_attributes_file(struct super_block *sb)
196 {
197 int err = 0;
198 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
199 struct inode *attr_file;
200 struct hfsplus_inode_info *hip;
201 u32 clump_size;
202 u16 node_size = HFSPLUS_ATTR_TREE_NODE_SIZE;
203 char *buf;
204 int index, written;
205 struct address_space *mapping;
206 struct page *page;
207 int old_state = HFSPLUS_EMPTY_ATTR_TREE;
208
209 hfs_dbg(ATTR_MOD, "create_attr_file: ino %d\n", HFSPLUS_ATTR_CNID);
210
211 check_attr_tree_state_again:
212 switch (atomic_read(&sbi->attr_tree_state)) {
213 case HFSPLUS_EMPTY_ATTR_TREE:
214 if (old_state != atomic_cmpxchg(&sbi->attr_tree_state,
215 old_state,
216 HFSPLUS_CREATING_ATTR_TREE))
217 goto check_attr_tree_state_again;
218 break;
219 case HFSPLUS_CREATING_ATTR_TREE:
220 /*
221 * This state means that another thread is in process
222 * of AttributesFile creation. Theoretically, it is
223 * possible to be here. But really __setxattr() method
224 * first of all calls hfs_find_init() for lookup in
225 * B-tree of CatalogFile. This method locks mutex of
226 * CatalogFile's B-tree. As a result, if some thread
227 * is inside AttributedFile creation operation then
228 * another threads will be waiting unlocking of
229 * CatalogFile's B-tree's mutex. However, if code will
230 * change then we will return error code (-EAGAIN) from
231 * here. Really, it means that first try to set of xattr
232 * fails with error but second attempt will have success.
233 */
234 return -EAGAIN;
235 case HFSPLUS_VALID_ATTR_TREE:
236 return 0;
237 case HFSPLUS_FAILED_ATTR_TREE:
238 return -EOPNOTSUPP;
239 default:
240 BUG();
241 }
242
243 attr_file = hfsplus_iget(sb, HFSPLUS_ATTR_CNID);
244 if (IS_ERR(attr_file)) {
245 pr_err("failed to load attributes file\n");
246 return PTR_ERR(attr_file);
247 }
248
249 BUG_ON(i_size_read(attr_file) != 0);
250
251 hip = HFSPLUS_I(attr_file);
252
253 clump_size = hfsplus_calc_btree_clump_size(sb->s_blocksize,
254 node_size,
255 sbi->sect_count,
256 HFSPLUS_ATTR_CNID);
257
258 mutex_lock(&hip->extents_lock);
259 hip->clump_blocks = clump_size >> sbi->alloc_blksz_shift;
260 mutex_unlock(&hip->extents_lock);
261
262 if (sbi->free_blocks <= (hip->clump_blocks << 1)) {
263 err = -ENOSPC;
264 goto end_attr_file_creation;
265 }
266
267 while (hip->alloc_blocks < hip->clump_blocks) {
268 err = hfsplus_file_extend(attr_file);
269 if (unlikely(err)) {
270 pr_err("failed to extend attributes file\n");
271 goto end_attr_file_creation;
272 }
273 hip->phys_size = attr_file->i_size =
274 (loff_t)hip->alloc_blocks << sbi->alloc_blksz_shift;
275 hip->fs_blocks = hip->alloc_blocks << sbi->fs_shift;
276 inode_set_bytes(attr_file, attr_file->i_size);
277 }
278
279 buf = kzalloc(node_size, GFP_NOFS);
280 if (!buf) {
281 pr_err("failed to allocate memory for header node\n");
282 err = -ENOMEM;
283 goto end_attr_file_creation;
284 }
285
286 hfsplus_init_header_node(attr_file, clump_size, buf, node_size);
287
288 mapping = attr_file->i_mapping;
289
290 index = 0;
291 written = 0;
292 for (; written < node_size; index++, written += PAGE_CACHE_SIZE) {
293 void *kaddr;
294
295 page = read_mapping_page(mapping, index, NULL);
296 if (IS_ERR(page)) {
297 err = PTR_ERR(page);
298 goto failed_header_node_init;
299 }
300
301 kaddr = kmap_atomic(page);
302 memcpy(kaddr, buf + written,
303 min_t(size_t, PAGE_CACHE_SIZE, node_size - written));
304 kunmap_atomic(kaddr);
305
306 set_page_dirty(page);
307 page_cache_release(page);
308 }
309
310 hfsplus_mark_inode_dirty(attr_file, HFSPLUS_I_ATTR_DIRTY);
311
312 sbi->attr_tree = hfs_btree_open(sb, HFSPLUS_ATTR_CNID);
313 if (!sbi->attr_tree)
314 pr_err("failed to load attributes file\n");
315
316 failed_header_node_init:
317 kfree(buf);
318
319 end_attr_file_creation:
320 iput(attr_file);
321
322 if (!err)
323 atomic_set(&sbi->attr_tree_state, HFSPLUS_VALID_ATTR_TREE);
324 else if (err == -ENOSPC)
325 atomic_set(&sbi->attr_tree_state, HFSPLUS_EMPTY_ATTR_TREE);
326 else
327 atomic_set(&sbi->attr_tree_state, HFSPLUS_FAILED_ATTR_TREE);
328
329 return err;
330 }
331
332 int __hfsplus_setxattr(struct inode *inode, const char *name,
333 const void *value, size_t size, int flags)
334 {
335 int err = 0;
336 struct hfs_find_data cat_fd;
337 hfsplus_cat_entry entry;
338 u16 cat_entry_flags, cat_entry_type;
339 u16 folder_finderinfo_len = sizeof(struct DInfo) +
340 sizeof(struct DXInfo);
341 u16 file_finderinfo_len = sizeof(struct FInfo) +
342 sizeof(struct FXInfo);
343
344 if ((!S_ISREG(inode->i_mode) &&
345 !S_ISDIR(inode->i_mode)) ||
346 HFSPLUS_IS_RSRC(inode))
347 return -EOPNOTSUPP;
348
349 err = can_set_xattr(inode, name, value, size);
350 if (err)
351 return err;
352
353 if (strncmp(name, XATTR_MAC_OSX_PREFIX,
354 XATTR_MAC_OSX_PREFIX_LEN) == 0)
355 name += XATTR_MAC_OSX_PREFIX_LEN;
356
357 if (value == NULL) {
358 value = "";
359 size = 0;
360 }
361
362 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
363 if (err) {
364 pr_err("can't init xattr find struct\n");
365 return err;
366 }
367
368 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
369 if (err) {
370 pr_err("catalog searching failed\n");
371 goto end_setxattr;
372 }
373
374 if (!strcmp_xattr_finder_info(name)) {
375 if (flags & XATTR_CREATE) {
376 pr_err("xattr exists yet\n");
377 err = -EOPNOTSUPP;
378 goto end_setxattr;
379 }
380 hfs_bnode_read(cat_fd.bnode, &entry, cat_fd.entryoffset,
381 sizeof(hfsplus_cat_entry));
382 if (be16_to_cpu(entry.type) == HFSPLUS_FOLDER) {
383 if (size == folder_finderinfo_len) {
384 memcpy(&entry.folder.user_info, value,
385 folder_finderinfo_len);
386 hfs_bnode_write(cat_fd.bnode, &entry,
387 cat_fd.entryoffset,
388 sizeof(struct hfsplus_cat_folder));
389 hfsplus_mark_inode_dirty(inode,
390 HFSPLUS_I_CAT_DIRTY);
391 } else {
392 err = -ERANGE;
393 goto end_setxattr;
394 }
395 } else if (be16_to_cpu(entry.type) == HFSPLUS_FILE) {
396 if (size == file_finderinfo_len) {
397 memcpy(&entry.file.user_info, value,
398 file_finderinfo_len);
399 hfs_bnode_write(cat_fd.bnode, &entry,
400 cat_fd.entryoffset,
401 sizeof(struct hfsplus_cat_file));
402 hfsplus_mark_inode_dirty(inode,
403 HFSPLUS_I_CAT_DIRTY);
404 } else {
405 err = -ERANGE;
406 goto end_setxattr;
407 }
408 } else {
409 err = -EOPNOTSUPP;
410 goto end_setxattr;
411 }
412 goto end_setxattr;
413 }
414
415 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) {
416 err = hfsplus_create_attributes_file(inode->i_sb);
417 if (unlikely(err))
418 goto end_setxattr;
419 }
420
421 if (hfsplus_attr_exists(inode, name)) {
422 if (flags & XATTR_CREATE) {
423 pr_err("xattr exists yet\n");
424 err = -EOPNOTSUPP;
425 goto end_setxattr;
426 }
427 err = hfsplus_delete_attr(inode, name);
428 if (err)
429 goto end_setxattr;
430 err = hfsplus_create_attr(inode, name, value, size);
431 if (err)
432 goto end_setxattr;
433 } else {
434 if (flags & XATTR_REPLACE) {
435 pr_err("cannot replace xattr\n");
436 err = -EOPNOTSUPP;
437 goto end_setxattr;
438 }
439 err = hfsplus_create_attr(inode, name, value, size);
440 if (err)
441 goto end_setxattr;
442 }
443
444 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
445 if (cat_entry_type == HFSPLUS_FOLDER) {
446 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
447 cat_fd.entryoffset +
448 offsetof(struct hfsplus_cat_folder, flags));
449 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
450 if (!strcmp_xattr_acl(name))
451 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
452 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
453 offsetof(struct hfsplus_cat_folder, flags),
454 cat_entry_flags);
455 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
456 } else if (cat_entry_type == HFSPLUS_FILE) {
457 cat_entry_flags = hfs_bnode_read_u16(cat_fd.bnode,
458 cat_fd.entryoffset +
459 offsetof(struct hfsplus_cat_file, flags));
460 cat_entry_flags |= HFSPLUS_XATTR_EXISTS;
461 if (!strcmp_xattr_acl(name))
462 cat_entry_flags |= HFSPLUS_ACL_EXISTS;
463 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
464 offsetof(struct hfsplus_cat_file, flags),
465 cat_entry_flags);
466 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
467 } else {
468 pr_err("invalid catalog entry type\n");
469 err = -EIO;
470 goto end_setxattr;
471 }
472
473 end_setxattr:
474 hfs_find_exit(&cat_fd);
475 return err;
476 }
477
478 static inline int is_osx_xattr(const char *xattr_name)
479 {
480 return !is_known_namespace(xattr_name);
481 }
482
483 static int name_len(const char *xattr_name, int xattr_name_len)
484 {
485 int len = xattr_name_len + 1;
486
487 if (is_osx_xattr(xattr_name))
488 len += XATTR_MAC_OSX_PREFIX_LEN;
489
490 return len;
491 }
492
493 static int copy_name(char *buffer, const char *xattr_name, int name_len)
494 {
495 int len = name_len;
496 int offset = 0;
497
498 if (is_osx_xattr(xattr_name)) {
499 strncpy(buffer, XATTR_MAC_OSX_PREFIX, XATTR_MAC_OSX_PREFIX_LEN);
500 offset += XATTR_MAC_OSX_PREFIX_LEN;
501 len += XATTR_MAC_OSX_PREFIX_LEN;
502 }
503
504 strncpy(buffer + offset, xattr_name, name_len);
505 memset(buffer + offset + name_len, 0, 1);
506 len += 1;
507
508 return len;
509 }
510
511 static ssize_t hfsplus_getxattr_finder_info(struct inode *inode,
512 void *value, size_t size)
513 {
514 ssize_t res = 0;
515 struct hfs_find_data fd;
516 u16 entry_type;
517 u16 folder_rec_len = sizeof(struct DInfo) + sizeof(struct DXInfo);
518 u16 file_rec_len = sizeof(struct FInfo) + sizeof(struct FXInfo);
519 u16 record_len = max(folder_rec_len, file_rec_len);
520 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
521 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
522
523 if (size >= record_len) {
524 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
525 if (res) {
526 pr_err("can't init xattr find struct\n");
527 return res;
528 }
529 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
530 if (res)
531 goto end_getxattr_finder_info;
532 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
533
534 if (entry_type == HFSPLUS_FOLDER) {
535 hfs_bnode_read(fd.bnode, folder_finder_info,
536 fd.entryoffset +
537 offsetof(struct hfsplus_cat_folder, user_info),
538 folder_rec_len);
539 memcpy(value, folder_finder_info, folder_rec_len);
540 res = folder_rec_len;
541 } else if (entry_type == HFSPLUS_FILE) {
542 hfs_bnode_read(fd.bnode, file_finder_info,
543 fd.entryoffset +
544 offsetof(struct hfsplus_cat_file, user_info),
545 file_rec_len);
546 memcpy(value, file_finder_info, file_rec_len);
547 res = file_rec_len;
548 } else {
549 res = -EOPNOTSUPP;
550 goto end_getxattr_finder_info;
551 }
552 } else
553 res = size ? -ERANGE : record_len;
554
555 end_getxattr_finder_info:
556 if (size >= record_len)
557 hfs_find_exit(&fd);
558 return res;
559 }
560
561 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
562 void *value, size_t size)
563 {
564 struct hfs_find_data fd;
565 hfsplus_attr_entry *entry;
566 __be32 xattr_record_type;
567 u32 record_type;
568 u16 record_length = 0;
569 ssize_t res = 0;
570
571 if ((!S_ISREG(inode->i_mode) &&
572 !S_ISDIR(inode->i_mode)) ||
573 HFSPLUS_IS_RSRC(inode))
574 return -EOPNOTSUPP;
575
576 if (strncmp(name, XATTR_MAC_OSX_PREFIX,
577 XATTR_MAC_OSX_PREFIX_LEN) == 0) {
578 /* skip "osx." prefix */
579 name += XATTR_MAC_OSX_PREFIX_LEN;
580 /*
581 * Don't allow retrieving properly prefixed attributes
582 * by prepending them with "osx."
583 */
584 if (is_known_namespace(name))
585 return -EOPNOTSUPP;
586 }
587
588 if (!strcmp_xattr_finder_info(name))
589 return hfsplus_getxattr_finder_info(inode, value, size);
590
591 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
592 return -EOPNOTSUPP;
593
594 entry = hfsplus_alloc_attr_entry();
595 if (!entry) {
596 pr_err("can't allocate xattr entry\n");
597 return -ENOMEM;
598 }
599
600 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
601 if (res) {
602 pr_err("can't init xattr find struct\n");
603 goto failed_getxattr_init;
604 }
605
606 res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd);
607 if (res) {
608 if (res == -ENOENT)
609 res = -ENODATA;
610 else
611 pr_err("xattr searching failed\n");
612 goto out;
613 }
614
615 hfs_bnode_read(fd.bnode, &xattr_record_type,
616 fd.entryoffset, sizeof(xattr_record_type));
617 record_type = be32_to_cpu(xattr_record_type);
618 if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
619 record_length = hfs_bnode_read_u16(fd.bnode,
620 fd.entryoffset +
621 offsetof(struct hfsplus_attr_inline_data,
622 length));
623 if (record_length > HFSPLUS_MAX_INLINE_DATA_SIZE) {
624 pr_err("invalid xattr record size\n");
625 res = -EIO;
626 goto out;
627 }
628 } else if (record_type == HFSPLUS_ATTR_FORK_DATA ||
629 record_type == HFSPLUS_ATTR_EXTENTS) {
630 pr_err("only inline data xattr are supported\n");
631 res = -EOPNOTSUPP;
632 goto out;
633 } else {
634 pr_err("invalid xattr record\n");
635 res = -EIO;
636 goto out;
637 }
638
639 if (size) {
640 hfs_bnode_read(fd.bnode, entry, fd.entryoffset,
641 offsetof(struct hfsplus_attr_inline_data,
642 raw_bytes) + record_length);
643 }
644
645 if (size >= record_length) {
646 memcpy(value, entry->inline_data.raw_bytes, record_length);
647 res = record_length;
648 } else
649 res = size ? -ERANGE : record_length;
650
651 out:
652 hfs_find_exit(&fd);
653
654 failed_getxattr_init:
655 hfsplus_destroy_attr_entry(entry);
656 return res;
657 }
658
659 static inline int can_list(const char *xattr_name)
660 {
661 if (!xattr_name)
662 return 0;
663
664 return strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
665 XATTR_TRUSTED_PREFIX_LEN) ||
666 capable(CAP_SYS_ADMIN);
667 }
668
669 static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
670 char *buffer, size_t size)
671 {
672 ssize_t res = 0;
673 struct inode *inode = dentry->d_inode;
674 struct hfs_find_data fd;
675 u16 entry_type;
676 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
677 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
678 unsigned long len, found_bit;
679 int xattr_name_len, symbols_count;
680
681 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
682 if (res) {
683 pr_err("can't init xattr find struct\n");
684 return res;
685 }
686
687 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
688 if (res)
689 goto end_listxattr_finder_info;
690
691 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
692 if (entry_type == HFSPLUS_FOLDER) {
693 len = sizeof(struct DInfo) + sizeof(struct DXInfo);
694 hfs_bnode_read(fd.bnode, folder_finder_info,
695 fd.entryoffset +
696 offsetof(struct hfsplus_cat_folder, user_info),
697 len);
698 found_bit = find_first_bit((void *)folder_finder_info, len*8);
699 } else if (entry_type == HFSPLUS_FILE) {
700 len = sizeof(struct FInfo) + sizeof(struct FXInfo);
701 hfs_bnode_read(fd.bnode, file_finder_info,
702 fd.entryoffset +
703 offsetof(struct hfsplus_cat_file, user_info),
704 len);
705 found_bit = find_first_bit((void *)file_finder_info, len*8);
706 } else {
707 res = -EOPNOTSUPP;
708 goto end_listxattr_finder_info;
709 }
710
711 if (found_bit >= (len*8))
712 res = 0;
713 else {
714 symbols_count = sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME) - 1;
715 xattr_name_len =
716 name_len(HFSPLUS_XATTR_FINDER_INFO_NAME, symbols_count);
717 if (!buffer || !size) {
718 if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME))
719 res = xattr_name_len;
720 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) {
721 if (size < xattr_name_len)
722 res = -ERANGE;
723 else {
724 res = copy_name(buffer,
725 HFSPLUS_XATTR_FINDER_INFO_NAME,
726 symbols_count);
727 }
728 }
729 }
730
731 end_listxattr_finder_info:
732 hfs_find_exit(&fd);
733
734 return res;
735 }
736
737 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
738 {
739 ssize_t err;
740 ssize_t res = 0;
741 struct inode *inode = dentry->d_inode;
742 struct hfs_find_data fd;
743 u16 key_len = 0;
744 struct hfsplus_attr_key attr_key;
745 char strbuf[HFSPLUS_ATTR_MAX_STRLEN +
746 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
747 int xattr_name_len;
748
749 if ((!S_ISREG(inode->i_mode) &&
750 !S_ISDIR(inode->i_mode)) ||
751 HFSPLUS_IS_RSRC(inode))
752 return -EOPNOTSUPP;
753
754 res = hfsplus_listxattr_finder_info(dentry, buffer, size);
755 if (res < 0)
756 return res;
757 else if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
758 return (res == 0) ? -EOPNOTSUPP : res;
759
760 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
761 if (err) {
762 pr_err("can't init xattr find struct\n");
763 return err;
764 }
765
766 err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
767 if (err) {
768 if (err == -ENOENT) {
769 if (res == 0)
770 res = -ENODATA;
771 goto end_listxattr;
772 } else {
773 res = err;
774 goto end_listxattr;
775 }
776 }
777
778 for (;;) {
779 key_len = hfs_bnode_read_u16(fd.bnode, fd.keyoffset);
780 if (key_len == 0 || key_len > fd.tree->max_key_len) {
781 pr_err("invalid xattr key length: %d\n", key_len);
782 res = -EIO;
783 goto end_listxattr;
784 }
785
786 hfs_bnode_read(fd.bnode, &attr_key,
787 fd.keyoffset, key_len + sizeof(key_len));
788
789 if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
790 goto end_listxattr;
791
792 xattr_name_len = HFSPLUS_ATTR_MAX_STRLEN;
793 if (hfsplus_uni2asc(inode->i_sb,
794 (const struct hfsplus_unistr *)&fd.key->attr.key_name,
795 strbuf, &xattr_name_len)) {
796 pr_err("unicode conversion failed\n");
797 res = -EIO;
798 goto end_listxattr;
799 }
800
801 if (!buffer || !size) {
802 if (can_list(strbuf))
803 res += name_len(strbuf, xattr_name_len);
804 } else if (can_list(strbuf)) {
805 if (size < (res + name_len(strbuf, xattr_name_len))) {
806 res = -ERANGE;
807 goto end_listxattr;
808 } else
809 res += copy_name(buffer + res,
810 strbuf, xattr_name_len);
811 }
812
813 if (hfs_brec_goto(&fd, 1))
814 goto end_listxattr;
815 }
816
817 end_listxattr:
818 hfs_find_exit(&fd);
819 return res;
820 }
821
822 int hfsplus_removexattr(struct dentry *dentry, const char *name)
823 {
824 int err = 0;
825 struct inode *inode = dentry->d_inode;
826 struct hfs_find_data cat_fd;
827 u16 flags;
828 u16 cat_entry_type;
829 int is_xattr_acl_deleted = 0;
830 int is_all_xattrs_deleted = 0;
831
832 if ((!S_ISREG(inode->i_mode) &&
833 !S_ISDIR(inode->i_mode)) ||
834 HFSPLUS_IS_RSRC(inode))
835 return -EOPNOTSUPP;
836
837 if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
838 return -EOPNOTSUPP;
839
840 err = can_set_xattr(inode, name, NULL, 0);
841 if (err)
842 return err;
843
844 if (strncmp(name, XATTR_MAC_OSX_PREFIX,
845 XATTR_MAC_OSX_PREFIX_LEN) == 0)
846 name += XATTR_MAC_OSX_PREFIX_LEN;
847
848 if (!strcmp_xattr_finder_info(name))
849 return -EOPNOTSUPP;
850
851 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
852 if (err) {
853 pr_err("can't init xattr find struct\n");
854 return err;
855 }
856
857 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
858 if (err) {
859 pr_err("catalog searching failed\n");
860 goto end_removexattr;
861 }
862
863 err = hfsplus_delete_attr(inode, name);
864 if (err)
865 goto end_removexattr;
866
867 is_xattr_acl_deleted = !strcmp_xattr_acl(name);
868 is_all_xattrs_deleted = !hfsplus_attr_exists(inode, NULL);
869
870 if (!is_xattr_acl_deleted && !is_all_xattrs_deleted)
871 goto end_removexattr;
872
873 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
874
875 if (cat_entry_type == HFSPLUS_FOLDER) {
876 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
877 offsetof(struct hfsplus_cat_folder, flags));
878 if (is_xattr_acl_deleted)
879 flags &= ~HFSPLUS_ACL_EXISTS;
880 if (is_all_xattrs_deleted)
881 flags &= ~HFSPLUS_XATTR_EXISTS;
882 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
883 offsetof(struct hfsplus_cat_folder, flags),
884 flags);
885 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
886 } else if (cat_entry_type == HFSPLUS_FILE) {
887 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
888 offsetof(struct hfsplus_cat_file, flags));
889 if (is_xattr_acl_deleted)
890 flags &= ~HFSPLUS_ACL_EXISTS;
891 if (is_all_xattrs_deleted)
892 flags &= ~HFSPLUS_XATTR_EXISTS;
893 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
894 offsetof(struct hfsplus_cat_file, flags),
895 flags);
896 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
897 } else {
898 pr_err("invalid catalog entry type\n");
899 err = -EIO;
900 goto end_removexattr;
901 }
902
903 end_removexattr:
904 hfs_find_exit(&cat_fd);
905 return err;
906 }
907
908 static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name,
909 void *buffer, size_t size, int type)
910 {
911 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
912 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
913 size_t len = strlen(name);
914
915 if (!strcmp(name, ""))
916 return -EINVAL;
917
918 if (len > HFSPLUS_ATTR_MAX_STRLEN)
919 return -EOPNOTSUPP;
920
921 strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
922 strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
923
924 return hfsplus_getxattr(dentry, xattr_name, buffer, size);
925 }
926
927 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
928 const void *buffer, size_t size, int flags, int type)
929 {
930 char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
931 XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
932 size_t len = strlen(name);
933
934 if (!strcmp(name, ""))
935 return -EINVAL;
936
937 if (len > HFSPLUS_ATTR_MAX_STRLEN)
938 return -EOPNOTSUPP;
939
940 strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
941 strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
942
943 return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
944 }
945
946 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,
947 size_t list_size, const char *name, size_t name_len, int type)
948 {
949 /*
950 * This method is not used.
951 * It is used hfsplus_listxattr() instead of generic_listxattr().
952 */
953 return -EOPNOTSUPP;
954 }
955
956 const struct xattr_handler hfsplus_xattr_osx_handler = {
957 .prefix = XATTR_MAC_OSX_PREFIX,
958 .list = hfsplus_osx_listxattr,
959 .get = hfsplus_osx_getxattr,
960 .set = hfsplus_osx_setxattr,
961 };
Linux kernel - Deliverables
This page took 0.057144 seconds and 6 git commands to generate.