1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * linux/fs/hfsplus/inode.c
4 *
5 * Copyright (C) 2001
6 * Brad Boyer (flar@allandria.com)
7 * (C) 2003 Ardis Technologies <roman@ardistech.com>
8 *
9 * Inode handling routines
10 */
11
12 #include <linux/blkdev.h>
13 #include <linux/mm.h>
14 #include <linux/fs.h>
15 #include <linux/pagemap.h>
16 #include <linux/mpage.h>
17 #include <linux/sched.h>
18 #include <linux/cred.h>
19 #include <linux/uio.h>
20 #include <linux/fileattr.h>
21
22 #include "hfsplus_fs.h"
23 #include "hfsplus_raw.h"
24 #include "xattr.h"
25
hfsplus_read_folio(struct file * file,struct folio * folio)26 static int hfsplus_read_folio(struct file *file, struct folio *folio)
27 {
28 return block_read_full_folio(folio, hfsplus_get_block);
29 }
30
hfsplus_write_failed(struct address_space * mapping,loff_t to)31 static void hfsplus_write_failed(struct address_space *mapping, loff_t to)
32 {
33 struct inode *inode = mapping->host;
34
35 if (to > inode->i_size) {
36 truncate_pagecache(inode, inode->i_size);
37 hfsplus_file_truncate(inode);
38 }
39 }
40
hfsplus_write_begin(const struct kiocb * iocb,struct address_space * mapping,loff_t pos,unsigned len,struct folio ** foliop,void ** fsdata)41 int hfsplus_write_begin(const struct kiocb *iocb,
42 struct address_space *mapping, loff_t pos,
43 unsigned len, struct folio **foliop,
44 void **fsdata)
45 {
46 int ret;
47
48 ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
49 hfsplus_get_block,
50 &HFSPLUS_I(mapping->host)->phys_size);
51 if (unlikely(ret))
52 hfsplus_write_failed(mapping, pos + len);
53
54 return ret;
55 }
56
hfsplus_bmap(struct address_space * mapping,sector_t block)57 static sector_t hfsplus_bmap(struct address_space *mapping, sector_t block)
58 {
59 return generic_block_bmap(mapping, block, hfsplus_get_block);
60 }
61
hfsplus_release_folio(struct folio * folio,gfp_t mask)62 static bool hfsplus_release_folio(struct folio *folio, gfp_t mask)
63 {
64 struct inode *inode = folio->mapping->host;
65 struct super_block *sb = inode->i_sb;
66 struct hfs_btree *tree;
67 struct hfs_bnode *node;
68 u32 nidx;
69 int i;
70 bool res = true;
71
72 switch (inode->i_ino) {
73 case HFSPLUS_EXT_CNID:
74 tree = HFSPLUS_SB(sb)->ext_tree;
75 break;
76 case HFSPLUS_CAT_CNID:
77 tree = HFSPLUS_SB(sb)->cat_tree;
78 break;
79 case HFSPLUS_ATTR_CNID:
80 tree = HFSPLUS_SB(sb)->attr_tree;
81 break;
82 default:
83 BUG();
84 return false;
85 }
86 if (!tree)
87 return false;
88 if (tree->node_size >= PAGE_SIZE) {
89 nidx = folio->index >>
90 (tree->node_size_shift - PAGE_SHIFT);
91 spin_lock(&tree->hash_lock);
92 node = hfs_bnode_findhash(tree, nidx);
93 if (!node)
94 ;
95 else if (atomic_read(&node->refcnt))
96 res = false;
97 if (res && node) {
98 hfs_bnode_unhash(node);
99 hfs_bnode_free(node);
100 }
101 spin_unlock(&tree->hash_lock);
102 } else {
103 nidx = folio->index <<
104 (PAGE_SHIFT - tree->node_size_shift);
105 i = 1 << (PAGE_SHIFT - tree->node_size_shift);
106 spin_lock(&tree->hash_lock);
107 do {
108 node = hfs_bnode_findhash(tree, nidx++);
109 if (!node)
110 continue;
111 if (atomic_read(&node->refcnt)) {
112 res = false;
113 break;
114 }
115 hfs_bnode_unhash(node);
116 hfs_bnode_free(node);
117 } while (--i && nidx < tree->node_count);
118 spin_unlock(&tree->hash_lock);
119 }
120 return res ? try_to_free_buffers(folio) : false;
121 }
122
hfsplus_direct_IO(struct kiocb * iocb,struct iov_iter * iter)123 static ssize_t hfsplus_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
124 {
125 struct file *file = iocb->ki_filp;
126 struct address_space *mapping = file->f_mapping;
127 struct inode *inode = mapping->host;
128 size_t count = iov_iter_count(iter);
129 ssize_t ret;
130
131 ret = blockdev_direct_IO(iocb, inode, iter, hfsplus_get_block);
132
133 /*
134 * In case of error extending write may have instantiated a few
135 * blocks outside i_size. Trim these off again.
136 */
137 if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {
138 loff_t isize = i_size_read(inode);
139 loff_t end = iocb->ki_pos + count;
140
141 if (end > isize)
142 hfsplus_write_failed(mapping, end);
143 }
144
145 return ret;
146 }
147
hfsplus_writepages(struct address_space * mapping,struct writeback_control * wbc)148 static int hfsplus_writepages(struct address_space *mapping,
149 struct writeback_control *wbc)
150 {
151 return mpage_writepages(mapping, wbc, hfsplus_get_block);
152 }
153
154 const struct address_space_operations hfsplus_btree_aops = {
155 .dirty_folio = block_dirty_folio,
156 .invalidate_folio = block_invalidate_folio,
157 .read_folio = hfsplus_read_folio,
158 .writepages = hfsplus_writepages,
159 .write_begin = hfsplus_write_begin,
160 .write_end = generic_write_end,
161 .migrate_folio = buffer_migrate_folio,
162 .bmap = hfsplus_bmap,
163 .release_folio = hfsplus_release_folio,
164 };
165
166 const struct address_space_operations hfsplus_aops = {
167 .dirty_folio = block_dirty_folio,
168 .invalidate_folio = block_invalidate_folio,
169 .read_folio = hfsplus_read_folio,
170 .write_begin = hfsplus_write_begin,
171 .write_end = generic_write_end,
172 .bmap = hfsplus_bmap,
173 .direct_IO = hfsplus_direct_IO,
174 .writepages = hfsplus_writepages,
175 .migrate_folio = buffer_migrate_folio,
176 };
177
178 const struct dentry_operations hfsplus_dentry_operations = {
179 .d_hash = hfsplus_hash_dentry,
180 .d_compare = hfsplus_compare_dentry,
181 };
182
hfsplus_get_perms(struct inode * inode,struct hfsplus_perm * perms,int dir)183 static int hfsplus_get_perms(struct inode *inode,
184 struct hfsplus_perm *perms, int dir)
185 {
186 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
187 u16 mode;
188
189 mode = be16_to_cpu(perms->mode);
190 if (dir) {
191 if (mode && !S_ISDIR(mode))
192 goto bad_type;
193 } else if (mode) {
194 switch (mode & S_IFMT) {
195 case S_IFREG:
196 case S_IFLNK:
197 case S_IFCHR:
198 case S_IFBLK:
199 case S_IFIFO:
200 case S_IFSOCK:
201 break;
202 default:
203 goto bad_type;
204 }
205 }
206
207 i_uid_write(inode, be32_to_cpu(perms->owner));
208 if ((test_bit(HFSPLUS_SB_UID, &sbi->flags)) || (!i_uid_read(inode) && !mode))
209 inode->i_uid = sbi->uid;
210
211 i_gid_write(inode, be32_to_cpu(perms->group));
212 if ((test_bit(HFSPLUS_SB_GID, &sbi->flags)) || (!i_gid_read(inode) && !mode))
213 inode->i_gid = sbi->gid;
214
215 if (dir) {
216 mode = mode ? (mode & S_IALLUGO) : (S_IRWXUGO & ~(sbi->umask));
217 mode |= S_IFDIR;
218 } else if (!mode)
219 mode = S_IFREG | ((S_IRUGO|S_IWUGO) & ~(sbi->umask));
220 inode->i_mode = mode;
221
222 HFSPLUS_I(inode)->userflags = perms->userflags;
223 if (perms->rootflags & HFSPLUS_FLG_IMMUTABLE)
224 inode->i_flags |= S_IMMUTABLE;
225 else
226 inode->i_flags &= ~S_IMMUTABLE;
227 if (perms->rootflags & HFSPLUS_FLG_APPEND)
228 inode->i_flags |= S_APPEND;
229 else
230 inode->i_flags &= ~S_APPEND;
231 return 0;
232 bad_type:
233 pr_err("invalid file type 0%04o for inode %llu\n", mode, inode->i_ino);
234 return -EIO;
235 }
236
hfsplus_file_open(struct inode * inode,struct file * file)237 static int hfsplus_file_open(struct inode *inode, struct file *file)
238 {
239 if (HFSPLUS_IS_RSRC(inode))
240 inode = HFSPLUS_I(inode)->rsrc_inode;
241 if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
242 return -EOVERFLOW;
243 atomic_inc(&HFSPLUS_I(inode)->opencnt);
244 return 0;
245 }
246
hfsplus_file_release(struct inode * inode,struct file * file)247 static int hfsplus_file_release(struct inode *inode, struct file *file)
248 {
249 struct super_block *sb = inode->i_sb;
250
251 if (HFSPLUS_IS_RSRC(inode))
252 inode = HFSPLUS_I(inode)->rsrc_inode;
253 if (atomic_dec_and_test(&HFSPLUS_I(inode)->opencnt)) {
254 inode_lock(inode);
255 hfsplus_file_truncate(inode);
256 if (inode->i_flags & S_DEAD) {
257 hfsplus_delete_cat(inode->i_ino,
258 HFSPLUS_SB(sb)->hidden_dir, NULL);
259 hfsplus_delete_inode(inode);
260 }
261 inode_unlock(inode);
262 }
263 return 0;
264 }
265
hfsplus_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)266 static int hfsplus_setattr(struct mnt_idmap *idmap,
267 struct dentry *dentry, struct iattr *attr)
268 {
269 struct inode *inode = d_inode(dentry);
270 int error;
271
272 error = setattr_prepare(&nop_mnt_idmap, dentry, attr);
273 if (error)
274 return error;
275
276 if ((attr->ia_valid & ATTR_SIZE) &&
277 attr->ia_size != i_size_read(inode)) {
278 inode_dio_wait(inode);
279 if (attr->ia_size > inode->i_size) {
280 error = generic_cont_expand_simple(inode,
281 attr->ia_size);
282 if (error)
283 return error;
284 }
285 truncate_setsize(inode, attr->ia_size);
286 hfsplus_file_truncate(inode);
287 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
288 }
289
290 setattr_copy(&nop_mnt_idmap, inode, attr);
291 mark_inode_dirty(inode);
292
293 return 0;
294 }
295
hfsplus_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int query_flags)296 int hfsplus_getattr(struct mnt_idmap *idmap, const struct path *path,
297 struct kstat *stat, u32 request_mask,
298 unsigned int query_flags)
299 {
300 struct inode *inode = d_inode(path->dentry);
301 struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
302
303 if (request_mask & STATX_BTIME) {
304 stat->result_mask |= STATX_BTIME;
305 stat->btime = hfsp_mt2ut(hip->create_date);
306 }
307
308 if (inode->i_flags & S_APPEND)
309 stat->attributes |= STATX_ATTR_APPEND;
310 if (inode->i_flags & S_IMMUTABLE)
311 stat->attributes |= STATX_ATTR_IMMUTABLE;
312 if (hip->userflags & HFSPLUS_FLG_NODUMP)
313 stat->attributes |= STATX_ATTR_NODUMP;
314
315 stat->attributes_mask |= STATX_ATTR_APPEND | STATX_ATTR_IMMUTABLE |
316 STATX_ATTR_NODUMP;
317
318 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
319 return 0;
320 }
321
hfsplus_file_fsync(struct file * file,loff_t start,loff_t end,int datasync)322 int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
323 int datasync)
324 {
325 struct inode *inode = file->f_mapping->host;
326 struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
327 struct super_block *sb = inode->i_sb;
328 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
329 struct hfsplus_vh *vhdr = sbi->s_vhdr;
330 int error = 0, error2;
331
332 hfs_dbg("inode->i_ino %llu, start %llu, end %llu\n",
333 inode->i_ino, start, end);
334
335 error = file_write_and_wait_range(file, start, end);
336 if (error)
337 return error;
338 inode_lock(inode);
339
340 /*
341 * Sync inode metadata into the catalog and extent trees.
342 */
343 sync_inode_metadata(inode, 1);
344
345 /*
346 * And explicitly write out the btrees.
347 */
348 if (test_and_clear_bit(HFSPLUS_I_CAT_DIRTY,
349 &HFSPLUS_I(HFSPLUS_CAT_TREE_I(sb))->flags)) {
350 clear_bit(HFSPLUS_I_CAT_DIRTY, &hip->flags);
351 error = filemap_write_and_wait(sbi->cat_tree->inode->i_mapping);
352 }
353
354 if (test_and_clear_bit(HFSPLUS_I_EXT_DIRTY,
355 &HFSPLUS_I(HFSPLUS_EXT_TREE_I(sb))->flags)) {
356 clear_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags);
357 error2 =
358 filemap_write_and_wait(sbi->ext_tree->inode->i_mapping);
359 if (!error)
360 error = error2;
361 }
362
363 if (sbi->attr_tree) {
364 if (test_and_clear_bit(HFSPLUS_I_ATTR_DIRTY,
365 &HFSPLUS_I(HFSPLUS_ATTR_TREE_I(sb))->flags)) {
366 clear_bit(HFSPLUS_I_ATTR_DIRTY, &hip->flags);
367 error2 =
368 filemap_write_and_wait(
369 sbi->attr_tree->inode->i_mapping);
370 if (!error)
371 error = error2;
372 }
373 } else {
374 if (test_and_clear_bit(HFSPLUS_I_ATTR_DIRTY, &hip->flags))
375 pr_err("sync non-existent attributes tree\n");
376 }
377
378 if (test_and_clear_bit(HFSPLUS_I_ALLOC_DIRTY,
379 &HFSPLUS_I(sbi->alloc_file)->flags)) {
380 clear_bit(HFSPLUS_I_ALLOC_DIRTY, &hip->flags);
381 error2 = filemap_write_and_wait(sbi->alloc_file->i_mapping);
382 if (!error)
383 error = error2;
384 }
385
386 mutex_lock(&sbi->vh_mutex);
387 hfsplus_prepare_volume_header_for_commit(vhdr);
388 mutex_unlock(&sbi->vh_mutex);
389
390 error2 = hfsplus_commit_superblock(inode->i_sb);
391 if (!error)
392 error = error2;
393
394 if (!test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
395 blkdev_issue_flush(inode->i_sb->s_bdev);
396
397 inode_unlock(inode);
398
399 return error;
400 }
401
402 static const struct inode_operations hfsplus_file_inode_operations = {
403 .setattr = hfsplus_setattr,
404 .getattr = hfsplus_getattr,
405 .listxattr = hfsplus_listxattr,
406 .fileattr_get = hfsplus_fileattr_get,
407 .fileattr_set = hfsplus_fileattr_set,
408 };
409
410 static const struct inode_operations hfsplus_symlink_inode_operations = {
411 .get_link = page_get_link,
412 .setattr = hfsplus_setattr,
413 .getattr = hfsplus_getattr,
414 .listxattr = hfsplus_listxattr,
415 };
416
417 static const struct inode_operations hfsplus_special_inode_operations = {
418 .setattr = hfsplus_setattr,
419 .getattr = hfsplus_getattr,
420 .listxattr = hfsplus_listxattr,
421 };
422
423 static const struct file_operations hfsplus_file_operations = {
424 .llseek = generic_file_llseek,
425 .read_iter = generic_file_read_iter,
426 .write_iter = generic_file_write_iter,
427 .mmap_prepare = generic_file_mmap_prepare,
428 .splice_read = filemap_splice_read,
429 .splice_write = iter_file_splice_write,
430 .fsync = hfsplus_file_fsync,
431 .open = hfsplus_file_open,
432 .release = hfsplus_file_release,
433 .unlocked_ioctl = hfsplus_ioctl,
434 };
435
hfsplus_new_inode(struct super_block * sb,struct inode * dir,umode_t mode)436 struct inode *hfsplus_new_inode(struct super_block *sb, struct inode *dir,
437 umode_t mode)
438 {
439 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
440 struct inode *inode = new_inode(sb);
441 struct hfsplus_inode_info *hip;
442
443 if (!inode)
444 return NULL;
445
446 inode->i_ino = sbi->next_cnid++;
447 inode_init_owner(&nop_mnt_idmap, inode, dir, mode);
448 set_nlink(inode, 1);
449 simple_inode_init_ts(inode);
450
451 hip = HFSPLUS_I(inode);
452 INIT_LIST_HEAD(&hip->open_dir_list);
453 spin_lock_init(&hip->open_dir_lock);
454 mutex_init(&hip->extents_lock);
455 atomic_set(&hip->opencnt, 0);
456 hip->extent_state = 0;
457 hip->flags = 0;
458 hip->userflags = 0;
459 hip->subfolders = 0;
460 memset(hip->first_extents, 0, sizeof(hfsplus_extent_rec));
461 memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec));
462 hip->alloc_blocks = 0;
463 hip->first_blocks = 0;
464 hip->cached_start = 0;
465 hip->cached_blocks = 0;
466 hip->phys_size = 0;
467 hip->fs_blocks = 0;
468 hip->rsrc_inode = NULL;
469 if (S_ISDIR(inode->i_mode)) {
470 inode->i_size = 2;
471 sbi->folder_count++;
472 inode->i_op = &hfsplus_dir_inode_operations;
473 inode->i_fop = &hfsplus_dir_operations;
474 } else if (S_ISREG(inode->i_mode)) {
475 sbi->file_count++;
476 inode->i_op = &hfsplus_file_inode_operations;
477 inode->i_fop = &hfsplus_file_operations;
478 inode->i_mapping->a_ops = &hfsplus_aops;
479 hip->clump_blocks = sbi->data_clump_blocks;
480 } else if (S_ISLNK(inode->i_mode)) {
481 sbi->file_count++;
482 inode->i_op = &hfsplus_symlink_inode_operations;
483 inode_nohighmem(inode);
484 inode->i_mapping->a_ops = &hfsplus_aops;
485 hip->clump_blocks = 1;
486 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
487 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
488 sbi->file_count++;
489 inode->i_op = &hfsplus_special_inode_operations;
490 } else
491 sbi->file_count++;
492
493 insert_inode_hash(inode);
494 mark_inode_dirty(inode);
495 hfsplus_mark_mdb_dirty(sb);
496
497 return inode;
498 }
499
hfsplus_delete_inode(struct inode * inode)500 void hfsplus_delete_inode(struct inode *inode)
501 {
502 struct super_block *sb = inode->i_sb;
503
504 if (S_ISDIR(inode->i_mode)) {
505 HFSPLUS_SB(sb)->folder_count--;
506 hfsplus_mark_mdb_dirty(sb);
507 return;
508 }
509 HFSPLUS_SB(sb)->file_count--;
510 if (S_ISREG(inode->i_mode)) {
511 if (!inode->i_nlink) {
512 inode->i_size = 0;
513 hfsplus_file_truncate(inode);
514 }
515 } else if (S_ISLNK(inode->i_mode)) {
516 inode->i_size = 0;
517 hfsplus_file_truncate(inode);
518 }
519 hfsplus_mark_mdb_dirty(sb);
520 }
521
hfsplus_inode_read_fork(struct inode * inode,struct hfsplus_fork_raw * fork)522 void hfsplus_inode_read_fork(struct inode *inode, struct hfsplus_fork_raw *fork)
523 {
524 struct super_block *sb = inode->i_sb;
525 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
526 struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
527 u32 count;
528 int i;
529
530 memcpy(&hip->first_extents, &fork->extents, sizeof(hfsplus_extent_rec));
531 for (count = 0, i = 0; i < 8; i++)
532 count += be32_to_cpu(fork->extents[i].block_count);
533 hip->first_blocks = count;
534 memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec));
535 hip->cached_start = 0;
536 hip->cached_blocks = 0;
537
538 hip->alloc_blocks = be32_to_cpu(fork->total_blocks);
539 hip->phys_size = inode->i_size = be64_to_cpu(fork->total_size);
540 hip->fs_blocks =
541 (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
542 inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits);
543 hip->clump_blocks =
544 be32_to_cpu(fork->clump_size) >> sbi->alloc_blksz_shift;
545 if (!hip->clump_blocks) {
546 hip->clump_blocks = HFSPLUS_IS_RSRC(inode) ?
547 sbi->rsrc_clump_blocks :
548 sbi->data_clump_blocks;
549 }
550 }
551
hfsplus_inode_write_fork(struct inode * inode,struct hfsplus_fork_raw * fork)552 void hfsplus_inode_write_fork(struct inode *inode,
553 struct hfsplus_fork_raw *fork)
554 {
555 memcpy(&fork->extents, &HFSPLUS_I(inode)->first_extents,
556 sizeof(hfsplus_extent_rec));
557 fork->total_size = cpu_to_be64(inode->i_size);
558 fork->total_blocks = cpu_to_be32(HFSPLUS_I(inode)->alloc_blocks);
559 }
560
hfsplus_cat_read_inode(struct inode * inode,struct hfs_find_data * fd)561 int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
562 {
563 hfsplus_cat_entry entry;
564 int res = 0;
565 u16 type;
566
567 type = hfs_bnode_read_u16(fd->bnode, fd->entryoffset);
568
569 HFSPLUS_I(inode)->linkid = 0;
570 if (type == HFSPLUS_FOLDER) {
571 struct hfsplus_cat_folder *folder = &entry.folder;
572
573 if (fd->entrylength < sizeof(struct hfsplus_cat_folder)) {
574 pr_err("bad catalog folder entry\n");
575 res = -EIO;
576 goto out;
577 }
578 hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
579 sizeof(struct hfsplus_cat_folder));
580 res = hfsplus_get_perms(inode, &folder->permissions, 1);
581 if (res)
582 goto out;
583 set_nlink(inode, 1);
584 inode->i_size = 2 + be32_to_cpu(folder->valence);
585 inode_set_atime_to_ts(inode, hfsp_mt2ut(folder->access_date));
586 inode_set_mtime_to_ts(inode,
587 hfsp_mt2ut(folder->content_mod_date));
588 inode_set_ctime_to_ts(inode,
589 hfsp_mt2ut(folder->attribute_mod_date));
590 HFSPLUS_I(inode)->create_date = folder->create_date;
591 HFSPLUS_I(inode)->fs_blocks = 0;
592 if (folder->flags & cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT)) {
593 HFSPLUS_I(inode)->subfolders =
594 be32_to_cpu(folder->subfolders);
595 }
596 inode->i_op = &hfsplus_dir_inode_operations;
597 inode->i_fop = &hfsplus_dir_operations;
598 } else if (type == HFSPLUS_FILE) {
599 struct hfsplus_cat_file *file = &entry.file;
600
601 if (fd->entrylength < sizeof(struct hfsplus_cat_file)) {
602 pr_err("bad catalog file entry\n");
603 res = -EIO;
604 goto out;
605 }
606 hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
607 sizeof(struct hfsplus_cat_file));
608
609 hfsplus_inode_read_fork(inode, HFSPLUS_IS_RSRC(inode) ?
610 &file->rsrc_fork : &file->data_fork);
611 res = hfsplus_get_perms(inode, &file->permissions, 0);
612 if (res)
613 goto out;
614 set_nlink(inode, 1);
615 if (S_ISREG(inode->i_mode)) {
616 if (file->permissions.dev)
617 set_nlink(inode,
618 be32_to_cpu(file->permissions.dev));
619 inode->i_op = &hfsplus_file_inode_operations;
620 inode->i_fop = &hfsplus_file_operations;
621 inode->i_mapping->a_ops = &hfsplus_aops;
622 } else if (S_ISLNK(inode->i_mode)) {
623 inode->i_op = &hfsplus_symlink_inode_operations;
624 inode_nohighmem(inode);
625 inode->i_mapping->a_ops = &hfsplus_aops;
626 } else {
627 inode->i_op = &hfsplus_special_inode_operations;
628 init_special_inode(inode, inode->i_mode,
629 be32_to_cpu(file->permissions.dev));
630 }
631 inode_set_atime_to_ts(inode, hfsp_mt2ut(file->access_date));
632 inode_set_mtime_to_ts(inode,
633 hfsp_mt2ut(file->content_mod_date));
634 inode_set_ctime_to_ts(inode,
635 hfsp_mt2ut(file->attribute_mod_date));
636 HFSPLUS_I(inode)->create_date = file->create_date;
637 } else {
638 pr_err("bad catalog entry used to create inode\n");
639 res = -EIO;
640 }
641 out:
642 return res;
643 }
644
hfsplus_cat_write_inode(struct inode * inode)645 int hfsplus_cat_write_inode(struct inode *inode)
646 {
647 struct inode *main_inode = inode;
648 struct hfs_btree *tree = HFSPLUS_SB(inode->i_sb)->cat_tree;
649 struct hfs_find_data fd;
650 hfsplus_cat_entry entry;
651 int res = 0;
652
653 hfs_dbg("inode->i_ino %llu\n", inode->i_ino);
654
655 if (HFSPLUS_IS_RSRC(inode))
656 main_inode = HFSPLUS_I(inode)->rsrc_inode;
657
658 if (!main_inode->i_nlink)
659 return 0;
660
661 if (hfs_find_init(tree, &fd))
662 /* panic? */
663 return -EIO;
664
665 if (hfsplus_find_cat(main_inode->i_sb, main_inode->i_ino, &fd))
666 /* panic? */
667 goto out;
668
669 if (S_ISDIR(main_inode->i_mode)) {
670 struct hfsplus_cat_folder *folder = &entry.folder;
671
672 if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) {
673 pr_err("bad catalog folder entry\n");
674 res = -EIO;
675 goto out;
676 }
677 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
678 sizeof(struct hfsplus_cat_folder));
679 /* simple node checks? */
680 hfsplus_cat_set_perms(inode, &folder->permissions);
681 folder->access_date = hfsp_ut2mt(inode_get_atime(inode));
682 folder->content_mod_date = hfsp_ut2mt(inode_get_mtime(inode));
683 folder->attribute_mod_date = hfsp_ut2mt(inode_get_ctime(inode));
684 folder->valence = cpu_to_be32(inode->i_size - 2);
685 if (folder->flags & cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT)) {
686 folder->subfolders =
687 cpu_to_be32(HFSPLUS_I(inode)->subfolders);
688 }
689 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
690 sizeof(struct hfsplus_cat_folder));
691 } else if (HFSPLUS_IS_RSRC(inode)) {
692 struct hfsplus_cat_file *file = &entry.file;
693 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
694 sizeof(struct hfsplus_cat_file));
695 hfsplus_inode_write_fork(inode, &file->rsrc_fork);
696 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
697 sizeof(struct hfsplus_cat_file));
698 } else {
699 struct hfsplus_cat_file *file = &entry.file;
700
701 if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
702 pr_err("bad catalog file entry\n");
703 res = -EIO;
704 goto out;
705 }
706 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
707 sizeof(struct hfsplus_cat_file));
708 hfsplus_inode_write_fork(inode, &file->data_fork);
709 hfsplus_cat_set_perms(inode, &file->permissions);
710 if (HFSPLUS_FLG_IMMUTABLE &
711 (file->permissions.rootflags |
712 file->permissions.userflags))
713 file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED);
714 else
715 file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED);
716 file->access_date = hfsp_ut2mt(inode_get_atime(inode));
717 file->content_mod_date = hfsp_ut2mt(inode_get_mtime(inode));
718 file->attribute_mod_date = hfsp_ut2mt(inode_get_ctime(inode));
719 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
720 sizeof(struct hfsplus_cat_file));
721 }
722
723 res = hfs_btree_write(tree);
724 if (res) {
725 pr_err("b-tree write err: %d, ino %llu\n",
726 res, inode->i_ino);
727 goto out;
728 }
729
730 set_bit(HFSPLUS_I_CAT_DIRTY,
731 &HFSPLUS_I(HFSPLUS_CAT_TREE_I(inode->i_sb))->flags);
732 set_bit(HFSPLUS_I_CAT_DIRTY, &HFSPLUS_I(inode)->flags);
733 out:
734 hfs_find_exit(&fd);
735
736 return res;
737 }
738
hfsplus_fileattr_get(struct dentry * dentry,struct file_kattr * fa)739 int hfsplus_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
740 {
741 struct inode *inode = d_inode(dentry);
742 struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
743 unsigned int flags = 0;
744
745 if (inode->i_flags & S_IMMUTABLE)
746 flags |= FS_IMMUTABLE_FL;
747 if (inode->i_flags & S_APPEND)
748 flags |= FS_APPEND_FL;
749 if (hip->userflags & HFSPLUS_FLG_NODUMP)
750 flags |= FS_NODUMP_FL;
751
752 fileattr_fill_flags(fa, flags);
753
754 return 0;
755 }
756
hfsplus_fileattr_set(struct mnt_idmap * idmap,struct dentry * dentry,struct file_kattr * fa)757 int hfsplus_fileattr_set(struct mnt_idmap *idmap,
758 struct dentry *dentry, struct file_kattr *fa)
759 {
760 struct inode *inode = d_inode(dentry);
761 struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
762 unsigned int new_fl = 0;
763
764 if (fileattr_has_fsx(fa))
765 return -EOPNOTSUPP;
766
767 /* don't silently ignore unsupported ext2 flags */
768 if (fa->flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL))
769 return -EOPNOTSUPP;
770
771 if (fa->flags & FS_IMMUTABLE_FL)
772 new_fl |= S_IMMUTABLE;
773
774 if (fa->flags & FS_APPEND_FL)
775 new_fl |= S_APPEND;
776
777 inode_set_flags(inode, new_fl, S_IMMUTABLE | S_APPEND);
778
779 if (fa->flags & FS_NODUMP_FL)
780 hip->userflags |= HFSPLUS_FLG_NODUMP;
781 else
782 hip->userflags &= ~HFSPLUS_FLG_NODUMP;
783
784 inode_set_ctime_current(inode);
785 mark_inode_dirty(inode);
786
787 return 0;
788 }
789