~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/hfsplus/xattr.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_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_SIZE, node_size - written));
235                 kunmap_atomic(kaddr);
236 
237                 set_page_dirty(page);
238                 put_page(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         xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
435                 GFP_KERNEL);
436         if (!xattr_name)
437                 return -ENOMEM;
438         strcpy(xattr_name, prefix);
439         strcpy(xattr_name + prefixlen, name);
440         res = __hfsplus_setxattr(d_inode(dentry), xattr_name, value, size,
441                                  flags);
442         kfree(xattr_name);
443         return res;
444 }
445 
446 static ssize_t hfsplus_getxattr_finder_info(struct inode *inode,
447                                                 void *value, size_t size)
448 {
449         ssize_t res = 0;
450         struct hfs_find_data fd;
451         u16 entry_type;
452         u16 folder_rec_len = sizeof(struct DInfo) + sizeof(struct DXInfo);
453         u16 file_rec_len = sizeof(struct FInfo) + sizeof(struct FXInfo);
454         u16 record_len = max(folder_rec_len, file_rec_len);
455         u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
456         u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
457 
458         if (size >= record_len) {
459                 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
460                 if (res) {
461                         pr_err("can't init xattr find struct\n");
462                         return res;
463                 }
464                 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
465                 if (res)
466                         goto end_getxattr_finder_info;
467                 entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
468 
469                 if (entry_type == HFSPLUS_FOLDER) {
470                         hfs_bnode_read(fd.bnode, folder_finder_info,
471                                 fd.entryoffset +
472                                 offsetof(struct hfsplus_cat_folder, user_info),
473                                 folder_rec_len);
474                         memcpy(value, folder_finder_info, folder_rec_len);
475                         res = folder_rec_len;
476                 } else if (entry_type == HFSPLUS_FILE) {
477                         hfs_bnode_read(fd.bnode, file_finder_info,
478                                 fd.entryoffset +
479                                 offsetof(struct hfsplus_cat_file, user_info),
480                                 file_rec_len);
481                         memcpy(value, file_finder_info, file_rec_len);
482                         res = file_rec_len;
483                 } else {
484                         res = -EOPNOTSUPP;
485                         goto end_getxattr_finder_info;
486                 }
487         } else
488                 res = size ? -ERANGE : record_len;
489 
490 end_getxattr_finder_info:
491         if (size >= record_len)
492                 hfs_find_exit(&fd);
493         return res;
494 }
495 
496 ssize_t __hfsplus_getxattr(struct inode *inode, const char *name,
497                          void *value, size_t size)
498 {
499         struct hfs_find_data fd;
500         hfsplus_attr_entry *entry;
501         __be32 xattr_record_type;
502         u32 record_type;
503         u16 record_length = 0;
504         ssize_t res = 0;
505 
506         if ((!S_ISREG(inode->i_mode) &&
507                         !S_ISDIR(inode->i_mode)) ||
508                                 HFSPLUS_IS_RSRC(inode))
509                 return -EOPNOTSUPP;
510 
511         if (!strcmp_xattr_finder_info(name))
512                 return hfsplus_getxattr_finder_info(inode, value, size);
513 
514         if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
515                 return -EOPNOTSUPP;
516 
517         entry = hfsplus_alloc_attr_entry();
518         if (!entry) {
519                 pr_err("can't allocate xattr entry\n");
520                 return -ENOMEM;
521         }
522 
523         res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
524         if (res) {
525                 pr_err("can't init xattr find struct\n");
526                 goto failed_getxattr_init;
527         }
528 
529         res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd);
530         if (res) {
531                 if (res == -ENOENT)
532                         res = -ENODATA;
533                 else
534                         pr_err("xattr searching failed\n");
535                 goto out;
536         }
537 
538         hfs_bnode_read(fd.bnode, &xattr_record_type,
539                         fd.entryoffset, sizeof(xattr_record_type));
540         record_type = be32_to_cpu(xattr_record_type);
541         if (record_type == HFSPLUS_ATTR_INLINE_DATA) {
542                 record_length = hfs_bnode_read_u16(fd.bnode,
543                                 fd.entryoffset +
544                                 offsetof(struct hfsplus_attr_inline_data,
545                                 length));
546                 if (record_length > HFSPLUS_MAX_INLINE_DATA_SIZE) {
547                         pr_err("invalid xattr record size\n");
548                         res = -EIO;
549                         goto out;
550                 }
551         } else if (record_type == HFSPLUS_ATTR_FORK_DATA ||
552                         record_type == HFSPLUS_ATTR_EXTENTS) {
553                 pr_err("only inline data xattr are supported\n");
554                 res = -EOPNOTSUPP;
555                 goto out;
556         } else {
557                 pr_err("invalid xattr record\n");
558                 res = -EIO;
559                 goto out;
560         }
561 
562         if (size) {
563                 hfs_bnode_read(fd.bnode, entry, fd.entryoffset,
564                                 offsetof(struct hfsplus_attr_inline_data,
565                                         raw_bytes) + record_length);
566         }
567 
568         if (size >= record_length) {
569                 memcpy(value, entry->inline_data.raw_bytes, record_length);
570                 res = record_length;
571         } else
572                 res = size ? -ERANGE : record_length;
573 
574 out:
575         hfs_find_exit(&fd);
576 
577 failed_getxattr_init:
578         hfsplus_destroy_attr_entry(entry);
579         return res;
580 }
581 
582 ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
583                          void *value, size_t size,
584                          const char *prefix, size_t prefixlen)
585 {
586         int res;
587         char *xattr_name;
588 
589         xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
590                              GFP_KERNEL);
591         if (!xattr_name)
592                 return -ENOMEM;
593 
594         strcpy(xattr_name, prefix);
595         strcpy(xattr_name + prefixlen, name);
596 
597         res = __hfsplus_getxattr(d_inode(dentry), xattr_name, value, size);
598         kfree(xattr_name);
599         return res;
600 
601 }
602 
603 static inline int can_list(const char *xattr_name)
604 {
605         if (!xattr_name)
606                 return 0;
607 
608         return strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
609                         XATTR_TRUSTED_PREFIX_LEN) ||
610                                 capable(CAP_SYS_ADMIN);
611 }
612 
613 static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
614                                                 char *buffer, size_t size)
615 {
616         ssize_t res = 0;
617         struct inode *inode = d_inode(dentry);
618         struct hfs_find_data fd;
619         u16 entry_type;
620         u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
621         u8 file_finder_info[sizeof(struct FInfo) + sizeof(struct FXInfo)];
622         unsigned long len, found_bit;
623         int xattr_name_len, symbols_count;
624 
625         res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
626         if (res) {
627                 pr_err("can't init xattr find struct\n");
628                 return res;
629         }
630 
631         res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
632         if (res)
633                 goto end_listxattr_finder_info;
634 
635         entry_type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
636         if (entry_type == HFSPLUS_FOLDER) {
637                 len = sizeof(struct DInfo) + sizeof(struct DXInfo);
638                 hfs_bnode_read(fd.bnode, folder_finder_info,
639                                 fd.entryoffset +
640                                 offsetof(struct hfsplus_cat_folder, user_info),
641                                 len);
642                 found_bit = find_first_bit((void *)folder_finder_info, len*8);
643         } else if (entry_type == HFSPLUS_FILE) {
644                 len = sizeof(struct FInfo) + sizeof(struct FXInfo);
645                 hfs_bnode_read(fd.bnode, file_finder_info,
646                                 fd.entryoffset +
647                                 offsetof(struct hfsplus_cat_file, user_info),
648                                 len);
649                 found_bit = find_first_bit((void *)file_finder_info, len*8);
650         } else {
651                 res = -EOPNOTSUPP;
652                 goto end_listxattr_finder_info;
653         }
654 
655         if (found_bit >= (len*8))
656                 res = 0;
657         else {
658                 symbols_count = sizeof(HFSPLUS_XATTR_FINDER_INFO_NAME) - 1;
659                 xattr_name_len =
660                         name_len(HFSPLUS_XATTR_FINDER_INFO_NAME, symbols_count);
661                 if (!buffer || !size) {
662                         if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME))
663                                 res = xattr_name_len;
664                 } else if (can_list(HFSPLUS_XATTR_FINDER_INFO_NAME)) {
665                         if (size < xattr_name_len)
666                                 res = -ERANGE;
667                         else {
668                                 res = copy_name(buffer,
669                                                 HFSPLUS_XATTR_FINDER_INFO_NAME,
670                                                 symbols_count);
671                         }
672                 }
673         }
674 
675 end_listxattr_finder_info:
676         hfs_find_exit(&fd);
677 
678         return res;
679 }
680 
681 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
682 {
683         ssize_t err;
684         ssize_t res = 0;
685         struct inode *inode = d_inode(dentry);
686         struct hfs_find_data fd;
687         u16 key_len = 0;
688         struct hfsplus_attr_key attr_key;
689         char *strbuf;
690         int xattr_name_len;
691 
692         if ((!S_ISREG(inode->i_mode) &&
693                         !S_ISDIR(inode->i_mode)) ||
694                                 HFSPLUS_IS_RSRC(inode))
695                 return -EOPNOTSUPP;
696 
697         res = hfsplus_listxattr_finder_info(dentry, buffer, size);
698         if (res < 0)
699                 return res;
700         else if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
701                 return (res == 0) ? -EOPNOTSUPP : res;
702 
703         err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd);
704         if (err) {
705                 pr_err("can't init xattr find struct\n");
706                 return err;
707         }
708 
709         strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN +
710                         XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
711         if (!strbuf) {
712                 res = -ENOMEM;
713                 goto out;
714         }
715 
716         err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
717         if (err) {
718                 if (err == -ENOENT) {
719                         if (res == 0)
720                                 res = -ENODATA;
721                         goto end_listxattr;
722                 } else {
723                         res = err;
724                         goto end_listxattr;
725                 }
726         }
727 
728         for (;;) {
729                 key_len = hfs_bnode_read_u16(fd.bnode, fd.keyoffset);
730                 if (key_len == 0 || key_len > fd.tree->max_key_len) {
731                         pr_err("invalid xattr key length: %d\n", key_len);
732                         res = -EIO;
733                         goto end_listxattr;
734                 }
735 
736                 hfs_bnode_read(fd.bnode, &attr_key,
737                                 fd.keyoffset, key_len + sizeof(key_len));
738 
739                 if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
740                         goto end_listxattr;
741 
742                 xattr_name_len = NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN;
743                 if (hfsplus_uni2asc(inode->i_sb,
744                         (const struct hfsplus_unistr *)&fd.key->attr.key_name,
745                                         strbuf, &xattr_name_len)) {
746                         pr_err("unicode conversion failed\n");
747                         res = -EIO;
748                         goto end_listxattr;
749                 }
750 
751                 if (!buffer || !size) {
752                         if (can_list(strbuf))
753                                 res += name_len(strbuf, xattr_name_len);
754                 } else if (can_list(strbuf)) {
755                         if (size < (res + name_len(strbuf, xattr_name_len))) {
756                                 res = -ERANGE;
757                                 goto end_listxattr;
758                         } else
759                                 res += copy_name(buffer + res,
760                                                 strbuf, xattr_name_len);
761                 }
762 
763                 if (hfs_brec_goto(&fd, 1))
764                         goto end_listxattr;
765         }
766 
767 end_listxattr:
768         kfree(strbuf);
769 out:
770         hfs_find_exit(&fd);
771         return res;
772 }
773 
774 static int hfsplus_removexattr(struct inode *inode, const char *name)
775 {
776         int err = 0;
777         struct hfs_find_data cat_fd;
778         u16 flags;
779         u16 cat_entry_type;
780         int is_xattr_acl_deleted = 0;
781         int is_all_xattrs_deleted = 0;
782 
783         if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
784                 return -EOPNOTSUPP;
785 
786         if (!strcmp_xattr_finder_info(name))
787                 return -EOPNOTSUPP;
788 
789         err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd);
790         if (err) {
791                 pr_err("can't init xattr find struct\n");
792                 return err;
793         }
794 
795         err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd);
796         if (err) {
797                 pr_err("catalog searching failed\n");
798                 goto end_removexattr;
799         }
800 
801         err = hfsplus_delete_attr(inode, name);
802         if (err)
803                 goto end_removexattr;
804 
805         is_xattr_acl_deleted = !strcmp_xattr_acl(name);
806         is_all_xattrs_deleted = !hfsplus_attr_exists(inode, NULL);
807 
808         if (!is_xattr_acl_deleted && !is_all_xattrs_deleted)
809                 goto end_removexattr;
810 
811         cat_entry_type = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset);
812 
813         if (cat_entry_type == HFSPLUS_FOLDER) {
814                 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
815                                 offsetof(struct hfsplus_cat_folder, flags));
816                 if (is_xattr_acl_deleted)
817                         flags &= ~HFSPLUS_ACL_EXISTS;
818                 if (is_all_xattrs_deleted)
819                         flags &= ~HFSPLUS_XATTR_EXISTS;
820                 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
821                                 offsetof(struct hfsplus_cat_folder, flags),
822                                 flags);
823                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
824         } else if (cat_entry_type == HFSPLUS_FILE) {
825                 flags = hfs_bnode_read_u16(cat_fd.bnode, cat_fd.entryoffset +
826                                 offsetof(struct hfsplus_cat_file, flags));
827                 if (is_xattr_acl_deleted)
828                         flags &= ~HFSPLUS_ACL_EXISTS;
829                 if (is_all_xattrs_deleted)
830                         flags &= ~HFSPLUS_XATTR_EXISTS;
831                 hfs_bnode_write_u16(cat_fd.bnode, cat_fd.entryoffset +
832                                 offsetof(struct hfsplus_cat_file, flags),
833                                 flags);
834                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
835         } else {
836                 pr_err("invalid catalog entry type\n");
837                 err = -EIO;
838                 goto end_removexattr;
839         }
840 
841 end_removexattr:
842         hfs_find_exit(&cat_fd);
843         return err;
844 }
845 
846 static int hfsplus_osx_getxattr(const struct xattr_handler *handler,
847                                 struct dentry *dentry, const char *name,
848                                 void *buffer, size_t size)
849 {
850         /*
851          * Don't allow retrieving properly prefixed attributes
852          * by prepending them with "osx."
853          */
854         if (is_known_namespace(name))
855                 return -EOPNOTSUPP;
856 
857         /*
858          * osx is the namespace we use to indicate an unprefixed
859          * attribute on the filesystem (like the ones that OS X
860          * creates), so we pass the name through unmodified (after
861          * ensuring it doesn't conflict with another namespace).
862          */
863         return __hfsplus_getxattr(d_inode(dentry), name, buffer, size);
864 }
865 
866 static int hfsplus_osx_setxattr(const struct xattr_handler *handler,
867                                 struct dentry *dentry, const char *name,
868                                 const void *buffer, size_t size, int flags)
869 {
870         /*
871          * Don't allow setting properly prefixed attributes
872          * by prepending them with "osx."
873          */
874         if (is_known_namespace(name))
875                 return -EOPNOTSUPP;
876 
877         /*
878          * osx is the namespace we use to indicate an unprefixed
879          * attribute on the filesystem (like the ones that OS X
880          * creates), so we pass the name through unmodified (after
881          * ensuring it doesn't conflict with another namespace).
882          */
883         return __hfsplus_setxattr(d_inode(dentry), name, buffer, size, flags);
884 }
885 
886 const struct xattr_handler hfsplus_xattr_osx_handler = {
887         .prefix = XATTR_MAC_OSX_PREFIX,
888         .get    = hfsplus_osx_getxattr,
889         .set    = hfsplus_osx_setxattr,
890 };
891 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp