1 /*
2 * linux/fs/hfs/inode.c
3 *
4 * Copyright (C) 1995-1997 Paul H. Hargrove
5 * (C) 2003 Ardis Technologies <roman@ardistech.com>
6 * This file may be distributed under the terms of the GNU General Public License.
7 *
8 * This file contains inode-related functions which do not depend on
9 * which scheme is being used to represent forks.
10 *
11 * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
12 */
13
14 #include <linux/pagemap.h>
15 #include <linux/mpage.h>
16 #include <linux/sched.h>
17 #include <linux/cred.h>
18 #include <linux/uio.h>
19 #include <linux/xattr.h>
20 #include <linux/blkdev.h>
21
22 #include "hfs_fs.h"
23 #include "btree.h"
24
25 static const struct file_operations hfs_file_operations;
26 static const struct inode_operations hfs_file_inode_operations;
27
28 /*================ Variable-like macros ================*/
29
30 #define HFS_VALID_MODE_BITS (S_IFREG | S_IFDIR | S_IRWXUGO)
31
hfs_read_folio(struct file * file,struct folio * folio)32 static int hfs_read_folio(struct file *file, struct folio *folio)
33 {
34 return block_read_full_folio(folio, hfs_get_block);
35 }
36
hfs_write_failed(struct address_space * mapping,loff_t to)37 static void hfs_write_failed(struct address_space *mapping, loff_t to)
38 {
39 struct inode *inode = mapping->host;
40
41 if (to > inode->i_size) {
42 truncate_pagecache(inode, inode->i_size);
43 hfs_file_truncate(inode);
44 }
45 }
46
hfs_write_begin(const struct kiocb * iocb,struct address_space * mapping,loff_t pos,unsigned int len,struct folio ** foliop,void ** fsdata)47 int hfs_write_begin(const struct kiocb *iocb, struct address_space *mapping,
48 loff_t pos, unsigned int len, struct folio **foliop,
49 void **fsdata)
50 {
51 int ret;
52
53 ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
54 hfs_get_block,
55 &HFS_I(mapping->host)->phys_size);
56 if (unlikely(ret))
57 hfs_write_failed(mapping, pos + len);
58
59 return ret;
60 }
61
hfs_bmap(struct address_space * mapping,sector_t block)62 static sector_t hfs_bmap(struct address_space *mapping, sector_t block)
63 {
64 return generic_block_bmap(mapping, block, hfs_get_block);
65 }
66
hfs_release_folio(struct folio * folio,gfp_t mask)67 static bool hfs_release_folio(struct folio *folio, gfp_t mask)
68 {
69 struct inode *inode = folio->mapping->host;
70 struct super_block *sb = inode->i_sb;
71 struct hfs_btree *tree;
72 struct hfs_bnode *node;
73 u32 nidx;
74 int i;
75 bool res = true;
76
77 switch (inode->i_ino) {
78 case HFS_EXT_CNID:
79 tree = HFS_SB(sb)->ext_tree;
80 break;
81 case HFS_CAT_CNID:
82 tree = HFS_SB(sb)->cat_tree;
83 break;
84 default:
85 BUG();
86 return false;
87 }
88
89 if (!tree)
90 return false;
91
92 if (tree->node_size >= PAGE_SIZE) {
93 nidx = folio->index >> (tree->node_size_shift - PAGE_SHIFT);
94 spin_lock(&tree->hash_lock);
95 node = hfs_bnode_findhash(tree, nidx);
96 if (!node)
97 ;
98 else if (atomic_read(&node->refcnt))
99 res = false;
100 if (res && node) {
101 hfs_bnode_unhash(node);
102 hfs_bnode_free(node);
103 }
104 spin_unlock(&tree->hash_lock);
105 } else {
106 nidx = folio->index << (PAGE_SHIFT - tree->node_size_shift);
107 i = 1 << (PAGE_SHIFT - tree->node_size_shift);
108 spin_lock(&tree->hash_lock);
109 do {
110 node = hfs_bnode_findhash(tree, nidx++);
111 if (!node)
112 continue;
113 if (atomic_read(&node->refcnt)) {
114 res = false;
115 break;
116 }
117 hfs_bnode_unhash(node);
118 hfs_bnode_free(node);
119 } while (--i && nidx < tree->node_count);
120 spin_unlock(&tree->hash_lock);
121 }
122 return res ? try_to_free_buffers(folio) : false;
123 }
124
hfs_direct_IO(struct kiocb * iocb,struct iov_iter * iter)125 static ssize_t hfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
126 {
127 struct file *file = iocb->ki_filp;
128 struct address_space *mapping = file->f_mapping;
129 struct inode *inode = mapping->host;
130 size_t count = iov_iter_count(iter);
131 ssize_t ret;
132
133 ret = blockdev_direct_IO(iocb, inode, iter, hfs_get_block);
134
135 /*
136 * In case of error extending write may have instantiated a few
137 * blocks outside i_size. Trim these off again.
138 */
139 if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {
140 loff_t isize = i_size_read(inode);
141 loff_t end = iocb->ki_pos + count;
142
143 if (end > isize)
144 hfs_write_failed(mapping, end);
145 }
146
147 return ret;
148 }
149
hfs_writepages(struct address_space * mapping,struct writeback_control * wbc)150 static int hfs_writepages(struct address_space *mapping,
151 struct writeback_control *wbc)
152 {
153 return mpage_writepages(mapping, wbc, hfs_get_block);
154 }
155
156 const struct address_space_operations hfs_btree_aops = {
157 .dirty_folio = block_dirty_folio,
158 .invalidate_folio = block_invalidate_folio,
159 .read_folio = hfs_read_folio,
160 .writepages = hfs_writepages,
161 .write_begin = hfs_write_begin,
162 .write_end = generic_write_end,
163 .migrate_folio = buffer_migrate_folio,
164 .bmap = hfs_bmap,
165 .release_folio = hfs_release_folio,
166 };
167
168 const struct address_space_operations hfs_aops = {
169 .dirty_folio = block_dirty_folio,
170 .invalidate_folio = block_invalidate_folio,
171 .read_folio = hfs_read_folio,
172 .write_begin = hfs_write_begin,
173 .write_end = generic_write_end,
174 .bmap = hfs_bmap,
175 .direct_IO = hfs_direct_IO,
176 .writepages = hfs_writepages,
177 .migrate_folio = buffer_migrate_folio,
178 };
179
180 /*
181 * hfs_new_inode
182 */
hfs_new_inode(struct inode * dir,const struct qstr * name,umode_t mode)183 struct inode *hfs_new_inode(struct inode *dir, const struct qstr *name, umode_t mode)
184 {
185 struct super_block *sb = dir->i_sb;
186 struct inode *inode = new_inode(sb);
187 s64 next_id;
188 s64 file_count;
189 s64 folder_count;
190 int err = -ENOMEM;
191
192 if (!inode)
193 goto out_err;
194
195 err = -ERANGE;
196
197 mutex_init(&HFS_I(inode)->extents_lock);
198 INIT_LIST_HEAD(&HFS_I(inode)->open_dir_list);
199 spin_lock_init(&HFS_I(inode)->open_dir_lock);
200 hfs_cat_build_key(sb, (btree_key *)&HFS_I(inode)->cat_key, dir->i_ino, name);
201 next_id = atomic64_inc_return(&HFS_SB(sb)->next_id);
202 if (next_id > U32_MAX) {
203 atomic64_dec(&HFS_SB(sb)->next_id);
204 pr_err("cannot create new inode: next CNID exceeds limit\n");
205 goto out_discard;
206 }
207 inode->i_ino = (u32)next_id;
208 inode->i_mode = mode;
209 inode->i_uid = current_fsuid();
210 inode->i_gid = current_fsgid();
211 set_nlink(inode, 1);
212 simple_inode_init_ts(inode);
213 HFS_I(inode)->flags = 0;
214 HFS_I(inode)->rsrc_inode = NULL;
215 HFS_I(inode)->fs_blocks = 0;
216 HFS_I(inode)->tz_secondswest = sys_tz.tz_minuteswest * 60;
217 if (S_ISDIR(mode)) {
218 inode->i_size = 2;
219 folder_count = atomic64_inc_return(&HFS_SB(sb)->folder_count);
220 if (folder_count> U32_MAX) {
221 atomic64_dec(&HFS_SB(sb)->folder_count);
222 pr_err("cannot create new inode: folder count exceeds limit\n");
223 goto out_discard;
224 }
225 if (dir->i_ino == HFS_ROOT_CNID)
226 HFS_SB(sb)->root_dirs++;
227 inode->i_op = &hfs_dir_inode_operations;
228 inode->i_fop = &hfs_dir_operations;
229 inode->i_mode |= S_IRWXUGO;
230 inode->i_mode &= ~HFS_SB(inode->i_sb)->s_dir_umask;
231 } else if (S_ISREG(mode)) {
232 HFS_I(inode)->clump_blocks = HFS_SB(sb)->clumpablks;
233 file_count = atomic64_inc_return(&HFS_SB(sb)->file_count);
234 if (file_count > U32_MAX) {
235 atomic64_dec(&HFS_SB(sb)->file_count);
236 pr_err("cannot create new inode: file count exceeds limit\n");
237 goto out_discard;
238 }
239 if (dir->i_ino == HFS_ROOT_CNID)
240 HFS_SB(sb)->root_files++;
241 inode->i_op = &hfs_file_inode_operations;
242 inode->i_fop = &hfs_file_operations;
243 inode->i_mapping->a_ops = &hfs_aops;
244 inode->i_mode |= S_IRUGO|S_IXUGO;
245 if (mode & S_IWUSR)
246 inode->i_mode |= S_IWUGO;
247 inode->i_mode &= ~HFS_SB(inode->i_sb)->s_file_umask;
248 HFS_I(inode)->phys_size = 0;
249 HFS_I(inode)->alloc_blocks = 0;
250 HFS_I(inode)->first_blocks = 0;
251 HFS_I(inode)->cached_start = 0;
252 HFS_I(inode)->cached_blocks = 0;
253 memset(HFS_I(inode)->first_extents, 0, sizeof(hfs_extent_rec));
254 memset(HFS_I(inode)->cached_extents, 0, sizeof(hfs_extent_rec));
255 }
256 insert_inode_hash(inode);
257 mark_inode_dirty(inode);
258 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
259 hfs_mark_mdb_dirty(sb);
260
261 return inode;
262
263 out_discard:
264 iput(inode);
265 out_err:
266 return ERR_PTR(err);
267 }
268
hfs_delete_inode(struct inode * inode)269 void hfs_delete_inode(struct inode *inode)
270 {
271 struct super_block *sb = inode->i_sb;
272
273 hfs_dbg("ino %lu\n", inode->i_ino);
274 if (S_ISDIR(inode->i_mode)) {
275 atomic64_dec(&HFS_SB(sb)->folder_count);
276 if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
277 HFS_SB(sb)->root_dirs--;
278 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
279 hfs_mark_mdb_dirty(sb);
280 return;
281 }
282
283 atomic64_dec(&HFS_SB(sb)->file_count);
284 if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
285 HFS_SB(sb)->root_files--;
286 if (S_ISREG(inode->i_mode)) {
287 if (!inode->i_nlink) {
288 inode->i_size = 0;
289 hfs_file_truncate(inode);
290 }
291 }
292 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
293 hfs_mark_mdb_dirty(sb);
294 }
295
hfs_inode_read_fork(struct inode * inode,struct hfs_extent * ext,__be32 __log_size,__be32 phys_size,u32 clump_size)296 void hfs_inode_read_fork(struct inode *inode, struct hfs_extent *ext,
297 __be32 __log_size, __be32 phys_size, u32 clump_size)
298 {
299 struct super_block *sb = inode->i_sb;
300 u32 log_size = be32_to_cpu(__log_size);
301 u16 count;
302 int i;
303
304 memcpy(HFS_I(inode)->first_extents, ext, sizeof(hfs_extent_rec));
305 for (count = 0, i = 0; i < 3; i++)
306 count += be16_to_cpu(ext[i].count);
307 HFS_I(inode)->first_blocks = count;
308 HFS_I(inode)->cached_start = 0;
309 HFS_I(inode)->cached_blocks = 0;
310
311 inode->i_size = HFS_I(inode)->phys_size = log_size;
312 HFS_I(inode)->fs_blocks = (log_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
313 inode_set_bytes(inode, HFS_I(inode)->fs_blocks << sb->s_blocksize_bits);
314 HFS_I(inode)->alloc_blocks = be32_to_cpu(phys_size) /
315 HFS_SB(sb)->alloc_blksz;
316 HFS_I(inode)->clump_blocks = clump_size / HFS_SB(sb)->alloc_blksz;
317 if (!HFS_I(inode)->clump_blocks)
318 HFS_I(inode)->clump_blocks = HFS_SB(sb)->clumpablks;
319 }
320
321 struct hfs_iget_data {
322 struct hfs_cat_key *key;
323 hfs_cat_rec *rec;
324 };
325
hfs_test_inode(struct inode * inode,void * data)326 static int hfs_test_inode(struct inode *inode, void *data)
327 {
328 struct hfs_iget_data *idata = data;
329 hfs_cat_rec *rec;
330
331 rec = idata->rec;
332 switch (rec->type) {
333 case HFS_CDR_DIR:
334 return inode->i_ino == be32_to_cpu(rec->dir.DirID);
335 case HFS_CDR_FIL:
336 return inode->i_ino == be32_to_cpu(rec->file.FlNum);
337 default:
338 BUG();
339 return 1;
340 }
341 }
342
343 /*
344 * hfs_read_inode
345 */
hfs_read_inode(struct inode * inode,void * data)346 static int hfs_read_inode(struct inode *inode, void *data)
347 {
348 struct hfs_iget_data *idata = data;
349 struct hfs_sb_info *hsb = HFS_SB(inode->i_sb);
350 hfs_cat_rec *rec;
351
352 HFS_I(inode)->flags = 0;
353 HFS_I(inode)->rsrc_inode = NULL;
354 mutex_init(&HFS_I(inode)->extents_lock);
355 INIT_LIST_HEAD(&HFS_I(inode)->open_dir_list);
356 spin_lock_init(&HFS_I(inode)->open_dir_lock);
357
358 /* Initialize the inode */
359 inode->i_uid = hsb->s_uid;
360 inode->i_gid = hsb->s_gid;
361 set_nlink(inode, 1);
362
363 if (idata->key)
364 HFS_I(inode)->cat_key = *idata->key;
365 else
366 HFS_I(inode)->flags |= HFS_FLG_RSRC;
367 HFS_I(inode)->tz_secondswest = sys_tz.tz_minuteswest * 60;
368
369 rec = idata->rec;
370 switch (rec->type) {
371 case HFS_CDR_FIL:
372 if (!HFS_IS_RSRC(inode)) {
373 hfs_inode_read_fork(inode, rec->file.ExtRec, rec->file.LgLen,
374 rec->file.PyLen, be16_to_cpu(rec->file.ClpSize));
375 } else {
376 hfs_inode_read_fork(inode, rec->file.RExtRec, rec->file.RLgLen,
377 rec->file.RPyLen, be16_to_cpu(rec->file.ClpSize));
378 }
379
380 inode->i_ino = be32_to_cpu(rec->file.FlNum);
381 inode->i_mode = S_IRUGO | S_IXUGO;
382 if (!(rec->file.Flags & HFS_FIL_LOCK))
383 inode->i_mode |= S_IWUGO;
384 inode->i_mode &= ~hsb->s_file_umask;
385 inode->i_mode |= S_IFREG;
386 inode_set_mtime_to_ts(inode,
387 inode_set_atime_to_ts(inode, inode_set_ctime_to_ts(inode, hfs_m_to_utime(rec->file.MdDat))));
388 inode->i_op = &hfs_file_inode_operations;
389 inode->i_fop = &hfs_file_operations;
390 inode->i_mapping->a_ops = &hfs_aops;
391 break;
392 case HFS_CDR_DIR:
393 inode->i_ino = be32_to_cpu(rec->dir.DirID);
394 inode->i_size = be16_to_cpu(rec->dir.Val) + 2;
395 HFS_I(inode)->fs_blocks = 0;
396 inode->i_mode = S_IFDIR | (S_IRWXUGO & ~hsb->s_dir_umask);
397 inode_set_mtime_to_ts(inode,
398 inode_set_atime_to_ts(inode, inode_set_ctime_to_ts(inode, hfs_m_to_utime(rec->dir.MdDat))));
399 inode->i_op = &hfs_dir_inode_operations;
400 inode->i_fop = &hfs_dir_operations;
401 break;
402 default:
403 make_bad_inode(inode);
404 }
405 return 0;
406 }
407
408 /*
409 * __hfs_iget()
410 *
411 * Given the MDB for a HFS filesystem, a 'key' and an 'entry' in
412 * the catalog B-tree and the 'type' of the desired file return the
413 * inode for that file/directory or NULL. Note that 'type' indicates
414 * whether we want the actual file or directory, or the corresponding
415 * metadata (AppleDouble header file or CAP metadata file).
416 */
hfs_iget(struct super_block * sb,struct hfs_cat_key * key,hfs_cat_rec * rec)417 struct inode *hfs_iget(struct super_block *sb, struct hfs_cat_key *key, hfs_cat_rec *rec)
418 {
419 struct hfs_iget_data data = { key, rec };
420 struct inode *inode;
421 u32 cnid;
422
423 switch (rec->type) {
424 case HFS_CDR_DIR:
425 cnid = be32_to_cpu(rec->dir.DirID);
426 break;
427 case HFS_CDR_FIL:
428 cnid = be32_to_cpu(rec->file.FlNum);
429 break;
430 default:
431 return NULL;
432 }
433 inode = iget5_locked(sb, cnid, hfs_test_inode, hfs_read_inode, &data);
434 if (inode && (inode_state_read_once(inode) & I_NEW))
435 unlock_new_inode(inode);
436 return inode;
437 }
438
hfs_inode_write_fork(struct inode * inode,struct hfs_extent * ext,__be32 * log_size,__be32 * phys_size)439 void hfs_inode_write_fork(struct inode *inode, struct hfs_extent *ext,
440 __be32 *log_size, __be32 *phys_size)
441 {
442 memcpy(ext, HFS_I(inode)->first_extents, sizeof(hfs_extent_rec));
443
444 if (log_size)
445 *log_size = cpu_to_be32(inode->i_size);
446 if (phys_size)
447 *phys_size = cpu_to_be32(HFS_I(inode)->alloc_blocks *
448 HFS_SB(inode->i_sb)->alloc_blksz);
449 }
450
hfs_write_inode(struct inode * inode,struct writeback_control * wbc)451 int hfs_write_inode(struct inode *inode, struct writeback_control *wbc)
452 {
453 struct inode *main_inode = inode;
454 struct hfs_find_data fd;
455 hfs_cat_rec rec;
456 int res;
457
458 hfs_dbg("ino %lu\n", inode->i_ino);
459 res = hfs_ext_write_extent(inode);
460 if (res)
461 return res;
462
463 if (inode->i_ino < HFS_FIRSTUSER_CNID) {
464 switch (inode->i_ino) {
465 case HFS_ROOT_CNID:
466 break;
467 case HFS_EXT_CNID:
468 hfs_btree_write(HFS_SB(inode->i_sb)->ext_tree);
469 return 0;
470 case HFS_CAT_CNID:
471 hfs_btree_write(HFS_SB(inode->i_sb)->cat_tree);
472 return 0;
473 default:
474 BUG();
475 return -EIO;
476 }
477 }
478
479 if (HFS_IS_RSRC(inode))
480 main_inode = HFS_I(inode)->rsrc_inode;
481
482 if (!main_inode->i_nlink)
483 return 0;
484
485 if (hfs_find_init(HFS_SB(main_inode->i_sb)->cat_tree, &fd))
486 /* panic? */
487 return -EIO;
488
489 res = -EIO;
490 if (HFS_I(main_inode)->cat_key.CName.len > HFS_NAMELEN)
491 goto out;
492 fd.search_key->cat = HFS_I(main_inode)->cat_key;
493 if (hfs_brec_find(&fd))
494 goto out;
495
496 if (S_ISDIR(main_inode->i_mode)) {
497 if (fd.entrylength < sizeof(struct hfs_cat_dir))
498 goto out;
499 hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
500 sizeof(struct hfs_cat_dir));
501 if (rec.type != HFS_CDR_DIR ||
502 be32_to_cpu(rec.dir.DirID) != inode->i_ino) {
503 }
504
505 rec.dir.MdDat = hfs_u_to_mtime(inode_get_mtime(inode));
506 rec.dir.Val = cpu_to_be16(inode->i_size - 2);
507
508 hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
509 sizeof(struct hfs_cat_dir));
510 } else if (HFS_IS_RSRC(inode)) {
511 if (fd.entrylength < sizeof(struct hfs_cat_file))
512 goto out;
513 hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
514 sizeof(struct hfs_cat_file));
515 hfs_inode_write_fork(inode, rec.file.RExtRec,
516 &rec.file.RLgLen, &rec.file.RPyLen);
517 hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
518 sizeof(struct hfs_cat_file));
519 } else {
520 if (fd.entrylength < sizeof(struct hfs_cat_file))
521 goto out;
522 hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
523 sizeof(struct hfs_cat_file));
524 if (rec.type != HFS_CDR_FIL ||
525 be32_to_cpu(rec.file.FlNum) != inode->i_ino) {
526 }
527
528 if (inode->i_mode & S_IWUSR)
529 rec.file.Flags &= ~HFS_FIL_LOCK;
530 else
531 rec.file.Flags |= HFS_FIL_LOCK;
532 hfs_inode_write_fork(inode, rec.file.ExtRec, &rec.file.LgLen, &rec.file.PyLen);
533 rec.file.MdDat = hfs_u_to_mtime(inode_get_mtime(inode));
534
535 hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
536 sizeof(struct hfs_cat_file));
537 }
538 res = 0;
539 out:
540 hfs_find_exit(&fd);
541 return res;
542 }
543
hfs_file_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)544 static struct dentry *hfs_file_lookup(struct inode *dir, struct dentry *dentry,
545 unsigned int flags)
546 {
547 struct inode *inode = NULL;
548 hfs_cat_rec rec;
549 struct hfs_find_data fd;
550 int res;
551
552 if (HFS_IS_RSRC(dir) || strcmp(dentry->d_name.name, "rsrc"))
553 goto out;
554
555 inode = HFS_I(dir)->rsrc_inode;
556 if (inode)
557 goto out;
558
559 inode = new_inode(dir->i_sb);
560 if (!inode)
561 return ERR_PTR(-ENOMEM);
562
563 res = hfs_find_init(HFS_SB(dir->i_sb)->cat_tree, &fd);
564 if (res) {
565 iput(inode);
566 return ERR_PTR(res);
567 }
568 fd.search_key->cat = HFS_I(dir)->cat_key;
569 res = hfs_brec_read(&fd, &rec, sizeof(rec));
570 if (!res) {
571 struct hfs_iget_data idata = { NULL, &rec };
572 hfs_read_inode(inode, &idata);
573 }
574 hfs_find_exit(&fd);
575 if (res) {
576 iput(inode);
577 return ERR_PTR(res);
578 }
579 HFS_I(inode)->rsrc_inode = dir;
580 HFS_I(dir)->rsrc_inode = inode;
581 igrab(dir);
582 inode_fake_hash(inode);
583 mark_inode_dirty(inode);
584 dont_mount(dentry);
585 out:
586 return d_splice_alias(inode, dentry);
587 }
588
hfs_evict_inode(struct inode * inode)589 void hfs_evict_inode(struct inode *inode)
590 {
591 truncate_inode_pages_final(&inode->i_data);
592 clear_inode(inode);
593 if (HFS_IS_RSRC(inode) && HFS_I(inode)->rsrc_inode) {
594 HFS_I(HFS_I(inode)->rsrc_inode)->rsrc_inode = NULL;
595 iput(HFS_I(inode)->rsrc_inode);
596 }
597 }
598
hfs_file_open(struct inode * inode,struct file * file)599 static int hfs_file_open(struct inode *inode, struct file *file)
600 {
601 if (HFS_IS_RSRC(inode))
602 inode = HFS_I(inode)->rsrc_inode;
603 atomic_inc(&HFS_I(inode)->opencnt);
604 return 0;
605 }
606
hfs_file_release(struct inode * inode,struct file * file)607 static int hfs_file_release(struct inode *inode, struct file *file)
608 {
609 //struct super_block *sb = inode->i_sb;
610
611 if (HFS_IS_RSRC(inode))
612 inode = HFS_I(inode)->rsrc_inode;
613 if (atomic_dec_and_test(&HFS_I(inode)->opencnt)) {
614 inode_lock(inode);
615 hfs_file_truncate(inode);
616 //if (inode->i_flags & S_DEAD) {
617 // hfs_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);
618 // hfs_delete_inode(inode);
619 //}
620 inode_unlock(inode);
621 }
622 return 0;
623 }
624
625 /*
626 * hfs_notify_change()
627 *
628 * Based very closely on fs/msdos/inode.c by Werner Almesberger
629 *
630 * This is the notify_change() field in the super_operations structure
631 * for HFS file systems. The purpose is to take that changes made to
632 * an inode and apply then in a filesystem-dependent manner. In this
633 * case the process has a few of tasks to do:
634 * 1) prevent changes to the i_uid and i_gid fields.
635 * 2) map file permissions to the closest allowable permissions
636 * 3) Since multiple Linux files can share the same on-disk inode under
637 * HFS (for instance the data and resource forks of a file) a change
638 * to permissions must be applied to all other in-core inodes which
639 * correspond to the same HFS file.
640 */
641
hfs_inode_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)642 int hfs_inode_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
643 struct iattr *attr)
644 {
645 struct inode *inode = d_inode(dentry);
646 struct hfs_sb_info *hsb = HFS_SB(inode->i_sb);
647 int error;
648
649 error = setattr_prepare(&nop_mnt_idmap, dentry,
650 attr); /* basic permission checks */
651 if (error)
652 return error;
653
654 /* no uig/gid changes and limit which mode bits can be set */
655 if (((attr->ia_valid & ATTR_UID) &&
656 (!uid_eq(attr->ia_uid, hsb->s_uid))) ||
657 ((attr->ia_valid & ATTR_GID) &&
658 (!gid_eq(attr->ia_gid, hsb->s_gid))) ||
659 ((attr->ia_valid & ATTR_MODE) &&
660 ((S_ISDIR(inode->i_mode) &&
661 (attr->ia_mode != inode->i_mode)) ||
662 (attr->ia_mode & ~HFS_VALID_MODE_BITS)))) {
663 return hsb->s_quiet ? 0 : error;
664 }
665
666 if (attr->ia_valid & ATTR_MODE) {
667 /* Only the 'w' bits can ever change and only all together. */
668 if (attr->ia_mode & S_IWUSR)
669 attr->ia_mode = inode->i_mode | S_IWUGO;
670 else
671 attr->ia_mode = inode->i_mode & ~S_IWUGO;
672 attr->ia_mode &= S_ISDIR(inode->i_mode) ? ~hsb->s_dir_umask: ~hsb->s_file_umask;
673 }
674
675 if ((attr->ia_valid & ATTR_SIZE) &&
676 attr->ia_size != i_size_read(inode)) {
677 inode_dio_wait(inode);
678
679 error = inode_newsize_ok(inode, attr->ia_size);
680 if (error)
681 return error;
682
683 truncate_setsize(inode, attr->ia_size);
684 hfs_file_truncate(inode);
685 simple_inode_init_ts(inode);
686 }
687
688 setattr_copy(&nop_mnt_idmap, inode, attr);
689 mark_inode_dirty(inode);
690 return 0;
691 }
692
hfs_file_fsync(struct file * filp,loff_t start,loff_t end,int datasync)693 static int hfs_file_fsync(struct file *filp, loff_t start, loff_t end,
694 int datasync)
695 {
696 struct inode *inode = filp->f_mapping->host;
697 struct super_block * sb;
698 int ret, err;
699
700 ret = file_write_and_wait_range(filp, start, end);
701 if (ret)
702 return ret;
703 inode_lock(inode);
704
705 /* sync the inode to buffers */
706 ret = write_inode_now(inode, 0);
707
708 /* sync the superblock to buffers */
709 sb = inode->i_sb;
710 flush_delayed_work(&HFS_SB(sb)->mdb_work);
711 /* .. finally sync the buffers to disk */
712 err = sync_blockdev(sb->s_bdev);
713 if (!ret)
714 ret = err;
715 inode_unlock(inode);
716 return ret;
717 }
718
719 static const struct file_operations hfs_file_operations = {
720 .llseek = generic_file_llseek,
721 .read_iter = generic_file_read_iter,
722 .write_iter = generic_file_write_iter,
723 .mmap_prepare = generic_file_mmap_prepare,
724 .splice_read = filemap_splice_read,
725 .splice_write = iter_file_splice_write,
726 .fsync = hfs_file_fsync,
727 .open = hfs_file_open,
728 .release = hfs_file_release,
729 };
730
731 static const struct inode_operations hfs_file_inode_operations = {
732 .lookup = hfs_file_lookup,
733 .setattr = hfs_inode_setattr,
734 .listxattr = generic_listxattr,
735 };
736