Pileus Git - ~andy/linux/blob - 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 };