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 <linux/posix_acl_xattr.h> 11 #include <linux/nls.h> 12 #include "xattr.h" 13 #include "acl.h" 14 15 static int hfsplus_removexattr(struct inode *inode, const char *name); 16 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, 24 #endif 25 &hfsplus_xattr_security_handler, 26 NULL 27 }; 28 29 static int strcmp_xattr_finder_info(const char *name) 30 { 31 if (name) { 32 return strncmp(name, HFSPLUS_XATTR_FINDER_INFO_NAME, 33 sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME)); 34 } 35 return -1; 36 } 37 38 static int strcmp_xattr_acl(const char *name) 39 { 40 if (name) { 41 return strncmp(name, HFSPLUS_XATTR_ACL_NAME, 42 sizeof(HFSPLUS_XATTR_ACL_NAME)); 43 } 44 return -1; 45 } 46 47 static bool is_known_namespace(const char *name) 48 { 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)) 53 return false; 54 55 return true; 56 } 57 58 static void hfsplus_init_header_node(struct inode *attr_file, 59 u32 clump_size, 60 char *buf, u16 node_size) 61 { 62 struct hfs_bnode_desc *desc; 63 struct hfs_btree_header_rec *head; 64 u16 offset; 65 __be16 *rec_offsets; 66 u32 hdr_node_map_rec_bits; 67 char *bmp; 68 u32 used_nodes; 69 u32 used_bmp_bytes; 70 u64 tmp; 71 72 hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %u\n", 73 clump_size, node_size); 74 75 /* The end of the node contains list of record offsets */ 76 rec_offsets = (__be16 *)(buf + node_size); 77 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); 83 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); 97 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) { 100 u32 map_node_bits; 101 u32 map_nodes; 102 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); 110 } 111 112 bmp = buf + offset; 113 used_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; 119 used_nodes %= 8; 120 } 121 *bmp = ~(0xFF >> used_nodes); 122 offset += hdr_node_map_rec_bits / 8; 123 *--rec_offsets = cpu_to_be16(offset); 124 } 125 126 static int hfsplus_create_attributes_file(struct super_block *sb) 127 { 128 int err = 0; 129 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb); 130 struct inode *attr_file; 131 struct hfsplus_inode_info *hip; 132 u32 clump_size; 133 u16 node_size = HFSPLUS_ATTR_TREE_NODE_SIZE; 134 char *buf; 135 int index, written; 136 struct address_space *mapping; 137 struct page *page; 138 int old_state = HFSPLUS_EMPTY_ATTR_TREE; 139 140 hfs_dbg(ATTR_MOD, "create_attr_file: ino %d\n", HFSPLUS_ATTR_CNID); 141 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, 146 old_state, 147 HFSPLUS_CREATING_ATTR_TREE)) 148 goto check_attr_tree_state_again; 149 break; 150 case HFSPLUS_CREATING_ATTR_TREE: 151 /* 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. 164 */ 165 return -EAGAIN; 166 case HFSPLUS_VALID_ATTR_TREE: 167 return 0; 168 case HFSPLUS_FAILED_ATTR_TREE: 169 return -EOPNOTSUPP; 170 default: 171 BUG(); 172 } 173 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); 178 } 179 180 BUG_ON(i_size_read(attr_file) != 0); 181 182 hip = HFSPLUS_I(attr_file); 183 184 clump_size = hfsplus_calc_btree_clump_size(sb->s_blocksize, 185 node_size, 186 sbi->sect_count, 187 HFSPLUS_ATTR_CNID); 188 189 mutex_lock(&hip->extents_lock); 190 hip->clump_blocks = clump_size >> sbi->alloc_blksz_shift; 191 mutex_unlock(&hip->extents_lock); 192 193 if (sbi->free_blocks <= (hip->clump_blocks << 1)) { 194 err = -ENOSPC; 195 goto end_attr_file_creation; 196 } 197 198 while (hip->alloc_blocks < hip->clump_blocks) { 199 err = hfsplus_file_extend(attr_file, false); 200 if (unlikely(err)) { 201 pr_err("failed to extend attributes file\n"); 202 goto end_attr_file_creation; 203 } 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); 208 } 209 210 buf = kzalloc(node_size, GFP_NOFS); 211 if (!buf) { 212 pr_err("failed to allocate memory for header node\n"); 213 err = -ENOMEM; 214 goto end_attr_file_creation; 215 } 216 217 hfsplus_init_header_node(attr_file, clump_size, buf, node_size); 218 219 mapping = attr_file->i_mapping; 220 221 index = 0; 222 written = 0; 223 for (; written < node_size; index++, written += PAGE_CACHE_SIZE) { 224 void *kaddr; 225 226 page = read_mapping_page(mapping, index, NULL); 227 if (IS_ERR(page)) { 228 err = PTR_ERR(page); 229 goto failed_header_node_init; 230 } 231 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); 236 237 set_page_dirty(page); 238 page_cache_release(page); 239 } 240 241 hfsplus_mark_inode_dirty(attr_file, HFSPLUS_I_ATTR_DIRTY); 242 243 sbi->attr_tree = hfs_btree_open(sb, HFSPLUS_ATTR_CNID); 244 if (!sbi->attr_tree) 245 pr_err("failed to load attributes file\n"); 246 247 failed_header_node_init: 248 kfree(buf); 249 250 end_attr_file_creation: 251 iput(attr_file); 252 253 if (!err) 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); 257 else 258 atomic_set(&sbi->attr_tree_state, HFSPLUS_FAILED_ATTR_TREE); 259 260 return err; 261 } 262 263 int __hfsplus_setxattr(struct inode *inode, const char *name, 264 const void *value, size_t size, int flags) 265 { 266 int err = 0; 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); 274 275 if ((!S_ISREG(inode->i_mode) && 276 !S_ISDIR(inode->i_mode)) || 277 HFSPLUS_IS_RSRC(inode)) 278 return -EOPNOTSUPP; 279 280 if (value == NULL) 281 return hfsplus_removexattr(inode, name); 282 283 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd); 284 if (err) { 285 pr_err("can't init xattr find struct\n"); 286 return err; 287 } 288 289 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd); 290 if (err) { 291 pr_err("catalog searching failed\n"); 292 goto end_setxattr; 293 } 294 295 if (!strcmp_xattr_finder_info(name)) { 296 if (flags & XATTR_CREATE) { 297 pr_err("xattr exists yet\n"); 298 err = -EOPNOTSUPP; 299 goto end_setxattr; 300 } 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, 308 cat_fd.entryoffset, 309 sizeof(struct hfsplus_cat_folder)); 310 hfsplus_mark_inode_dirty(inode, 311 HFSPLUS_I_CAT_DIRTY); 312 } else { 313 err = -ERANGE; 314 goto end_setxattr; 315 } 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, 321 cat_fd.entryoffset, 322 sizeof(struct hfsplus_cat_file)); 323 hfsplus_mark_inode_dirty(inode, 324 HFSPLUS_I_CAT_DIRTY); 325 } else { 326 err = -ERANGE; 327 goto end_setxattr; 328 } 329 } else { 330 err = -EOPNOTSUPP; 331 goto end_setxattr; 332 } 333 goto end_setxattr; 334 } 335 336 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) { 337 err = hfsplus_create_attributes_file(inode->i_sb); 338 if (unlikely(err)) 339 goto end_setxattr; 340 } 341 342 if (hfsplus_attr_exists(inode, name)) { 343 if (flags & XATTR_CREATE) { 344 pr_err("xattr exists yet\n"); 345 err = -EOPNOTSUPP; 346 goto end_setxattr; 347 } 348 err = hfsplus_delete_attr(inode, name); 349 if (err) 350 goto end_setxattr; 351 err = hfsplus_create_attr(inode, name, value, size); 352 if (err) 353 goto end_setxattr; 354 } else { 355 if (flags & XATTR_REPLACE) { 356 pr_err("cannot replace xattr\n"); 357 err = -EOPNOTSUPP; 358 goto end_setxattr; 359 } 360 err = hfsplus_create_attr(inode, name, value, size); 361 if (err) 362 goto end_setxattr; 363 } 364 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, 368 cat_fd.entryoffset + 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), 375 cat_entry_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, 379 cat_fd.entryoffset + 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), 386 cat_entry_flags); 387 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY); 388 } else { 389 pr_err("invalid catalog entry type\n"); 390 err = -EIO; 391 goto end_setxattr; 392 } 393 394 end_setxattr: 395 hfs_find_exit(&cat_fd); 396 return err; 397 } 398 399 static int name_len(const char *xattr_name, int xattr_name_len) 400 { 401 int len = xattr_name_len + 1; 402 403 if (!is_known_namespace(xattr_name)) 404 len += XATTR_MAC_OSX_PREFIX_LEN; 405 406 return len; 407 } 408 409 static int copy_name(char *buffer, const char *xattr_name, int name_len) 410 { 411 int len = name_len; 412 int offset = 0; 413 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; 418 } 419 420 strncpy(buffer + offset, xattr_name, name_len); 421 memset(buffer + offset + name_len, 0, 1); 422 len += 1; 423 424 return len; 425 } 426 427 int hfsplus_setxattr(struct dentry *dentry, const char *name, 428 const void *value, size_t size, int flags, 429 const char *prefix, size_t prefixlen) 430 { 431 char *xattr_name; 432 int res; 433 434 if (!strcmp(name, "")) 435 return -EINVAL; 436 437 xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1, 438 GFP_KERNEL); 439 if (!xattr_name) 440 return -ENOMEM; 441 strcpy(xattr_name, prefix); 442 strcpy(xattr_name + prefixlen, name); 443 res = __hfsplus_setxattr(d_inode(dentry), xattr_name, value, size, 444 flags); 445 kfree(xattr_name); 446 return res; 447 } 448 449 static ssize_t hfsplus_getxattr_finder_info(struct inode *inode, 450 void *value, size_t size) 451 { 452 ssize_t res = 0; 453 struct hfs_find_data fd; 454 u16 entry_type; 455 u16 folder_rec_len = sizeof(struct DInfo) + sizeof(struct DXInfo); 456 u16 file_rec_len = sizeof(struct FInfo) + sizeof(struct FXInfo); 457 u16 record_len = max(folder_rec_len, file_rec_len); 458 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)]; 459 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)]; 460 461 if (size >= record_len) { 462 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd); 463 if (res) { 464 pr_err("can't init xattr find struct\n"); 465 return res; 466 } 467 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); 468 if (res) 469 goto end_getxattr_finder_info; 470 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset); 471 472 if (entry_type == HFSPLUS_FOLDER) { 473 hfs_bnode_read(fd.bnode, folder_finder_info, 474 fd.entryoffset + 475 offsetof(struct hfsplus_cat_folder, user_info), 476 folder_rec_len); 477 memcpy(value, folder_finder_info, folder_rec_len); 478 res = folder_rec_len; 479 } else if (entry_type == HFSPLUS_FILE) { 480 hfs_bnode_read(fd.bnode, file_finder_info, 481 fd.entryoffset + 482 offsetof(struct hfsplus_cat_file, user_info), 483 file_rec_len); 484 memcpy(value, file_finder_info, file_rec_len); 485 res = file_rec_len; 486 } else { 487 res = -EOPNOTSUPP; 488 goto end_getxattr_finder_info; 489 } 490 } else 491 res = size ? -ERANGE : record_len; 492 493 end_getxattr_finder_info: 494 if (size >= record_len) 495 hfs_find_exit(&fd); 496 return res; 497 } 498 499 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name, 500 void *value, size_t size) 501 { 502 struct hfs_find_data fd; 503 hfsplus_attr_entry *entry; 504 __be32 xattr_record_type; 505 u32 record_type; 506 u16 record_length = 0; 507 ssize_t res = 0; 508 509 if ((!S_ISREG(inode->i_mode) && 510 !S_ISDIR(inode->i_mode)) || 511 HFSPLUS_IS_RSRC(inode)) 512 return -EOPNOTSUPP; 513 514 if (!strcmp_xattr_finder_info(name)) 515 return hfsplus_getxattr_finder_info(inode, value, size); 516 517 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) 518 return -EOPNOTSUPP; 519 520 entry = hfsplus_alloc_attr_entry(); 521 if (!entry) { 522 pr_err("can't allocate xattr entry\n"); 523 return -ENOMEM; 524 } 525 526 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd); 527 if (res) { 528 pr_err("can't init xattr find struct\n"); 529 goto failed_getxattr_init; 530 } 531 532 res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd); 533 if (res) { 534 if (res == -ENOENT) 535 res = -ENODATA; 536 else 537 pr_err("xattr searching failed\n"); 538 goto out; 539 } 540 541 hfs_bnode_read(fd.bnode, &xattr_record_type, 542 fd.entryoffset, sizeof(xattr_record_type)); 543 record_type = be32_to_cpu(xattr_record_type); 544 if (record_type == HFSPLUS_ATTR_INLINE_DATA) { 545 record_length = hfs_bnode_read_u16(fd.bnode, 546 fd.entryoffset + 547 offsetof(struct hfsplus_attr_inline_data, 548 length)); 549 if (record_length > HFSPLUS_MAX_INLINE_DATA_SIZE) { 550 pr_err("invalid xattr record size\n"); 551 res = -EIO; 552 goto out; 553 } 554 } else if (record_type == HFSPLUS_ATTR_FORK_DATA || 555 record_type == HFSPLUS_ATTR_EXTENTS) { 556 pr_err("only inline data xattr are supported\n"); 557 res = -EOPNOTSUPP; 558 goto out; 559 } else { 560 pr_err("invalid xattr record\n"); 561 res = -EIO; 562 goto out; 563 } 564 565 if (size) { 566 hfs_bnode_read(fd.bnode, entry, fd.entryoffset, 567 offsetof(struct hfsplus_attr_inline_data, 568 raw_bytes) + record_length); 569 } 570 571 if (size >= record_length) { 572 memcpy(value, entry->inline_data.raw_bytes, record_length); 573 res = record_length; 574 } else 575 res = size ? -ERANGE : record_length; 576 577 out: 578 hfs_find_exit(&fd); 579 580 failed_getxattr_init: 581 hfsplus_destroy_attr_entry(entry); 582 return res; 583 } 584 585 ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name, 586 void *value, size_t size, 587 const char *prefix, size_t prefixlen) 588 { 589 int res; 590 char *xattr_name; 591 592 if (!strcmp(name, "")) 593 return -EINVAL; 594 595 xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1, 596 GFP_KERNEL); 597 if (!xattr_name) 598 return -ENOMEM; 599 600 strcpy(xattr_name, prefix); 601 strcpy(xattr_name + prefixlen, name); 602 603 res = __hfsplus_getxattr(d_inode(dentry), xattr_name, value, size); 604 kfree(xattr_name); 605 return res; 606 607 } 608 609 static inline int can_list(const char *xattr_name) 610 { 611 if (!xattr_name) 612 return 0; 613 614 return strncmp(xattr_name, XATTR_TRUSTED_PREFIX, 615 XATTR_TRUSTED_PREFIX_LEN) || 616 capable(CAP_SYS_ADMIN); 617 } 618 619 static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry, 620 char *buffer, size_t size) 621 { 622 ssize_t res = 0; 623 struct inode *inode = d_inode(dentry); 624 struct hfs_find_data fd; 625 u16 entry_type; 626 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)]; 627 u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)]; 628 unsigned long len, found_bit; 629 int xattr_name_len, symbols_count; 630 631 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd); 632 if (res) { 633 pr_err("can't init xattr find struct\n"); 634 return res; 635 } 636 637 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); 638 if (res) 639 goto end_listxattr_finder_info; 640 641 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset); 642 if (entry_type == HFSPLUS_FOLDER) { 643 len = sizeof(struct DInfo) + sizeof(struct DXInfo); 644 hfs_bnode_read(fd.bnode, folder_finder_info, 645 fd.entryoffset + 646 offsetof(struct hfsplus_cat_folder, user_info), 647 len); 648 found_bit = find_first_bit((void *)folder_finder_info, len*8); 649 } else if (entry_type == HFSPLUS_FILE) { 650 len = sizeof(struct FInfo) + sizeof(struct FXInfo); 651 hfs_bnode_read(fd.bnode, file_finder_info, 652 fd.entryoffset + 653 offsetof(struct hfsplus_cat_file, user_info), 654 len); 655 found_bit = find_first_bit((void *)file_finder_info, len*8); 656 } else { 657 res = -EOPNOTSUPP; 658 goto end_listxattr_finder_info; 659 } 660 661 if (found_bit >= (len*8)) 662 res = 0; 663 else { 664 symbols_count = sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME) - 1; 665 xattr_name_len = 666 name_len(HFSPLUS_XATTR_FINDER_INFO_NAME, symbols_count); 667 if (!buffer || !size) { 668 if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) 669 res = xattr_name_len; 670 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) { 671 if (size < xattr_name_len) 672 res = -ERANGE; 673 else { 674 res = copy_name(buffer, 675 HFSPLUS_XATTR_FINDER_INFO_NAME, 676 symbols_count); 677 } 678 } 679 } 680 681 end_listxattr_finder_info: 682 hfs_find_exit(&fd); 683 684 return res; 685 } 686 687 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size) 688 { 689 ssize_t err; 690 ssize_t res = 0; 691 struct inode *inode = d_inode(dentry); 692 struct hfs_find_data fd; 693 u16 key_len = 0; 694 struct hfsplus_attr_key attr_key; 695 char *strbuf; 696 int xattr_name_len; 697 698 if ((!S_ISREG(inode->i_mode) && 699 !S_ISDIR(inode->i_mode)) || 700 HFSPLUS_IS_RSRC(inode)) 701 return -EOPNOTSUPP; 702 703 res = hfsplus_listxattr_finder_info(dentry, buffer, size); 704 if (res < 0) 705 return res; 706 else if (!HFSPLUS_SB(inode->i_sb)->attr_tree) 707 return (res == 0) ? -EOPNOTSUPP : res; 708 709 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd); 710 if (err) { 711 pr_err("can't init xattr find struct\n"); 712 return err; 713 } 714 715 strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 716 XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL); 717 if (!strbuf) { 718 res = -ENOMEM; 719 goto out; 720 } 721 722 err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd); 723 if (err) { 724 if (err == -ENOENT) { 725 if (res == 0) 726 res = -ENODATA; 727 goto end_listxattr; 728 } else { 729 res = err; 730 goto end_listxattr; 731 } 732 } 733 734 for (;;) { 735 key_len = hfs_bnode_read_u16(fd.bnode, fd.keyoffset); 736 if (key_len == 0 || key_len > fd.tree->max_key_len) { 737 pr_err("invalid xattr key length: %d\n", key_len); 738 res = -EIO; 739 goto end_listxattr; 740 } 741 742 hfs_bnode_read(fd.bnode, &attr_key, 743 fd.keyoffset, key_len + sizeof(key_len)); 744 745 if (be32_to_cpu(attr_key.cnid) != inode->i_ino) 746 goto end_listxattr; 747 748 xattr_name_len = NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN; 749 if (hfsplus_uni2asc(inode->i_sb, 750 (const struct hfsplus_unistr *)&fd.key->attr.key_name, 751 strbuf, &xattr_name_len)) { 752 pr_err("unicode conversion failed\n"); 753 res = -EIO; 754 goto end_listxattr; 755 } 756 757 if (!buffer || !size) { 758 if (can_list(strbuf)) 759 res += name_len(strbuf, xattr_name_len); 760 } else if (can_list(strbuf)) { 761 if (size < (res + name_len(strbuf, xattr_name_len))) { 762 res = -ERANGE; 763 goto end_listxattr; 764 } else 765 res += copy_name(buffer + res, 766 strbuf, xattr_name_len); 767 } 768 769 if (hfs_brec_goto(&fd, 1)) 770 goto end_listxattr; 771 } 772 773 end_listxattr: 774 kfree(strbuf); 775 out: 776 hfs_find_exit(&fd); 777 return res; 778 } 779 780 static int hfsplus_removexattr(struct inode *inode, const char *name) 781 { 782 int err = 0; 783 struct hfs_find_data cat_fd; 784 u16 flags; 785 u16 cat_entry_type; 786 int is_xattr_acl_deleted = 0; 787 int is_all_xattrs_deleted = 0; 788 789 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) 790 return -EOPNOTSUPP; 791 792 if (!strcmp_xattr_finder_info(name)) 793 return -EOPNOTSUPP; 794 795 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd); 796 if (err) { 797 pr_err("can't init xattr find struct\n"); 798 return err; 799 } 800 801 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd); 802 if (err) { 803 pr_err("catalog searching failed\n"); 804 goto end_removexattr; 805 } 806 807 err = hfsplus_delete_attr(inode, name); 808 if (err) 809 goto end_removexattr; 810 811 is_xattr_acl_deleted = !strcmp_xattr_acl(name); 812 is_all_xattrs_deleted = !hfsplus_attr_exists(inode, NULL); 813 814 if (!is_xattr_acl_deleted && !is_all_xattrs_deleted) 815 goto end_removexattr; 816 817 cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset); 818 819 if (cat_entry_type == HFSPLUS_FOLDER) { 820 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset + 821 offsetof(struct hfsplus_cat_folder, flags)); 822 if (is_xattr_acl_deleted) 823 flags &= ~HFSPLUS_ACL_EXISTS; 824 if (is_all_xattrs_deleted) 825 flags &= ~HFSPLUS_XATTR_EXISTS; 826 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset + 827 offsetof(struct hfsplus_cat_folder, flags), 828 flags); 829 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY); 830 } else if (cat_entry_type == HFSPLUS_FILE) { 831 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset + 832 offsetof(struct hfsplus_cat_file, flags)); 833 if (is_xattr_acl_deleted) 834 flags &= ~HFSPLUS_ACL_EXISTS; 835 if (is_all_xattrs_deleted) 836 flags &= ~HFSPLUS_XATTR_EXISTS; 837 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset + 838 offsetof(struct hfsplus_cat_file, flags), 839 flags); 840 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY); 841 } else { 842 pr_err("invalid catalog entry type\n"); 843 err = -EIO; 844 goto end_removexattr; 845 } 846 847 end_removexattr: 848 hfs_find_exit(&cat_fd); 849 return err; 850 } 851 852 static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name, 853 void *buffer, size_t size, int type) 854 { 855 if (!strcmp(name, "")) 856 return -EINVAL; 857 858 /* 859 * Don't allow retrieving properly prefixed attributes 860 * by prepending them with "osx." 861 */ 862 if (is_known_namespace(name)) 863 return -EOPNOTSUPP; 864 865 /* 866 * osx is the namespace we use to indicate an unprefixed 867 * attribute on the filesystem (like the ones that OS X 868 * creates), so we pass the name through unmodified (after 869 * ensuring it doesn't conflict with another namespace). 870 */ 871 return __hfsplus_getxattr(d_inode(dentry), name, buffer, size); 872 } 873 874 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name, 875 const void *buffer, size_t size, int flags, int type) 876 { 877 if (!strcmp(name, "")) 878 return -EINVAL; 879 880 /* 881 * Don't allow setting properly prefixed attributes 882 * by prepending them with "osx." 883 */ 884 if (is_known_namespace(name)) 885 return -EOPNOTSUPP; 886 887 /* 888 * osx is the namespace we use to indicate an unprefixed 889 * attribute on the filesystem (like the ones that OS X 890 * creates), so we pass the name through unmodified (after 891 * ensuring it doesn't conflict with another namespace). 892 */ 893 return __hfsplus_setxattr(d_inode(dentry), name, buffer, size, flags); 894 } 895 896 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list, 897 size_t list_size, const char *name, size_t name_len, int type) 898 { 899 /* 900 * This method is not used. 901 * It is used hfsplus_listxattr() instead of generic_listxattr(). 902 */ 903 return -EOPNOTSUPP; 904 } 905 906 const struct xattr_handler hfsplus_xattr_osx_handler = { 907 .prefix = XATTR_MAC_OSX_PREFIX, 908 .list = hfsplus_osx_listxattr, 909 .get = hfsplus_osx_getxattr, 910 .set = hfsplus_osx_setxattr, 911 }; 912