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