2 * linux/fs/hfsplus/inode.c
5 * Brad Boyer (flar@allandria.com)
6 * (C) 2003 Ardis Technologies <roman@ardistech.com>
8 * Inode handling routines
11 #include <linux/blkdev.h>
14 #include <linux/pagemap.h>
15 #include <linux/mpage.h>
16 #include <linux/sched.h>
18 #include "hfsplus_fs.h"
19 #include "hfsplus_raw.h"
21 static int hfsplus_readpage(struct file
*file
, struct page
*page
)
23 return block_read_full_page(page
, hfsplus_get_block
);
26 static int hfsplus_writepage(struct page
*page
, struct writeback_control
*wbc
)
28 return block_write_full_page(page
, hfsplus_get_block
, wbc
);
31 static int hfsplus_write_begin(struct file
*file
, struct address_space
*mapping
,
32 loff_t pos
, unsigned len
, unsigned flags
,
33 struct page
**pagep
, void **fsdata
)
38 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
40 &HFSPLUS_I(mapping
->host
)->phys_size
);
42 loff_t isize
= mapping
->host
->i_size
;
43 if (pos
+ len
> isize
)
44 vmtruncate(mapping
->host
, isize
);
50 static sector_t
hfsplus_bmap(struct address_space
*mapping
, sector_t block
)
52 return generic_block_bmap(mapping
, block
, hfsplus_get_block
);
55 static int hfsplus_releasepage(struct page
*page
, gfp_t mask
)
57 struct inode
*inode
= page
->mapping
->host
;
58 struct super_block
*sb
= inode
->i_sb
;
59 struct hfs_btree
*tree
;
60 struct hfs_bnode
*node
;
64 switch (inode
->i_ino
) {
65 case HFSPLUS_EXT_CNID
:
66 tree
= HFSPLUS_SB(sb
)->ext_tree
;
68 case HFSPLUS_CAT_CNID
:
69 tree
= HFSPLUS_SB(sb
)->cat_tree
;
71 case HFSPLUS_ATTR_CNID
:
72 tree
= HFSPLUS_SB(sb
)->attr_tree
;
80 if (tree
->node_size
>= PAGE_CACHE_SIZE
) {
82 (tree
->node_size_shift
- PAGE_CACHE_SHIFT
);
83 spin_lock(&tree
->hash_lock
);
84 node
= hfs_bnode_findhash(tree
, nidx
);
87 else if (atomic_read(&node
->refcnt
))
90 hfs_bnode_unhash(node
);
93 spin_unlock(&tree
->hash_lock
);
96 (PAGE_CACHE_SHIFT
- tree
->node_size_shift
);
97 i
= 1 << (PAGE_CACHE_SHIFT
- tree
->node_size_shift
);
98 spin_lock(&tree
->hash_lock
);
100 node
= hfs_bnode_findhash(tree
, nidx
++);
103 if (atomic_read(&node
->refcnt
)) {
107 hfs_bnode_unhash(node
);
108 hfs_bnode_free(node
);
109 } while (--i
&& nidx
< tree
->node_count
);
110 spin_unlock(&tree
->hash_lock
);
112 return res
? try_to_free_buffers(page
) : 0;
115 static ssize_t
hfsplus_direct_IO(int rw
, struct kiocb
*iocb
,
116 const struct iovec
*iov
, loff_t offset
, unsigned long nr_segs
)
118 struct file
*file
= iocb
->ki_filp
;
119 struct inode
*inode
= file
->f_path
.dentry
->d_inode
->i_mapping
->host
;
122 ret
= blockdev_direct_IO(rw
, iocb
, inode
, iov
, offset
, nr_segs
,
126 * In case of error extending write may have instantiated a few
127 * blocks outside i_size. Trim these off again.
129 if (unlikely((rw
& WRITE
) && ret
< 0)) {
130 loff_t isize
= i_size_read(inode
);
131 loff_t end
= offset
+ iov_length(iov
, nr_segs
);
134 vmtruncate(inode
, isize
);
140 static int hfsplus_writepages(struct address_space
*mapping
,
141 struct writeback_control
*wbc
)
143 return mpage_writepages(mapping
, wbc
, hfsplus_get_block
);
146 const struct address_space_operations hfsplus_btree_aops
= {
147 .readpage
= hfsplus_readpage
,
148 .writepage
= hfsplus_writepage
,
149 .write_begin
= hfsplus_write_begin
,
150 .write_end
= generic_write_end
,
151 .bmap
= hfsplus_bmap
,
152 .releasepage
= hfsplus_releasepage
,
155 const struct address_space_operations hfsplus_aops
= {
156 .readpage
= hfsplus_readpage
,
157 .writepage
= hfsplus_writepage
,
158 .write_begin
= hfsplus_write_begin
,
159 .write_end
= generic_write_end
,
160 .bmap
= hfsplus_bmap
,
161 .direct_IO
= hfsplus_direct_IO
,
162 .writepages
= hfsplus_writepages
,
165 const struct dentry_operations hfsplus_dentry_operations
= {
166 .d_hash
= hfsplus_hash_dentry
,
167 .d_compare
= hfsplus_compare_dentry
,
170 static struct dentry
*hfsplus_file_lookup(struct inode
*dir
,
171 struct dentry
*dentry
, unsigned int flags
)
173 struct hfs_find_data fd
;
174 struct super_block
*sb
= dir
->i_sb
;
175 struct inode
*inode
= NULL
;
176 struct hfsplus_inode_info
*hip
;
179 if (HFSPLUS_IS_RSRC(dir
) || strcmp(dentry
->d_name
.name
, "rsrc"))
182 inode
= HFSPLUS_I(dir
)->rsrc_inode
;
186 inode
= new_inode(sb
);
188 return ERR_PTR(-ENOMEM
);
190 hip
= HFSPLUS_I(inode
);
191 inode
->i_ino
= dir
->i_ino
;
192 INIT_LIST_HEAD(&hip
->open_dir_list
);
193 mutex_init(&hip
->extents_lock
);
194 hip
->extent_state
= 0;
197 set_bit(HFSPLUS_I_RSRC
, &hip
->flags
);
199 err
= hfs_find_init(HFSPLUS_SB(sb
)->cat_tree
, &fd
);
201 err
= hfsplus_find_cat(sb
, dir
->i_ino
, &fd
);
203 err
= hfsplus_cat_read_inode(inode
, &fd
);
210 hip
->rsrc_inode
= dir
;
211 HFSPLUS_I(dir
)->rsrc_inode
= inode
;
215 * __mark_inode_dirty expects inodes to be hashed. Since we don't
216 * want resource fork inodes in the regular inode space, we make them
217 * appear hashed, but do not put on any lists. hlist_del()
218 * will work fine and require no locking.
220 hlist_add_fake(&inode
->i_hash
);
222 mark_inode_dirty(inode
);
224 d_add(dentry
, inode
);
228 static void hfsplus_get_perms(struct inode
*inode
,
229 struct hfsplus_perm
*perms
, int dir
)
231 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(inode
->i_sb
);
234 mode
= be16_to_cpu(perms
->mode
);
236 inode
->i_uid
= be32_to_cpu(perms
->owner
);
237 if (!inode
->i_uid
&& !mode
)
238 inode
->i_uid
= sbi
->uid
;
240 inode
->i_gid
= be32_to_cpu(perms
->group
);
241 if (!inode
->i_gid
&& !mode
)
242 inode
->i_gid
= sbi
->gid
;
245 mode
= mode
? (mode
& S_IALLUGO
) : (S_IRWXUGO
& ~(sbi
->umask
));
248 mode
= S_IFREG
| ((S_IRUGO
|S_IWUGO
) & ~(sbi
->umask
));
249 inode
->i_mode
= mode
;
251 HFSPLUS_I(inode
)->userflags
= perms
->userflags
;
252 if (perms
->rootflags
& HFSPLUS_FLG_IMMUTABLE
)
253 inode
->i_flags
|= S_IMMUTABLE
;
255 inode
->i_flags
&= ~S_IMMUTABLE
;
256 if (perms
->rootflags
& HFSPLUS_FLG_APPEND
)
257 inode
->i_flags
|= S_APPEND
;
259 inode
->i_flags
&= ~S_APPEND
;
262 static int hfsplus_file_open(struct inode
*inode
, struct file
*file
)
264 if (HFSPLUS_IS_RSRC(inode
))
265 inode
= HFSPLUS_I(inode
)->rsrc_inode
;
266 if (!(file
->f_flags
& O_LARGEFILE
) && i_size_read(inode
) > MAX_NON_LFS
)
268 atomic_inc(&HFSPLUS_I(inode
)->opencnt
);
272 static int hfsplus_file_release(struct inode
*inode
, struct file
*file
)
274 struct super_block
*sb
= inode
->i_sb
;
276 if (HFSPLUS_IS_RSRC(inode
))
277 inode
= HFSPLUS_I(inode
)->rsrc_inode
;
278 if (atomic_dec_and_test(&HFSPLUS_I(inode
)->opencnt
)) {
279 mutex_lock(&inode
->i_mutex
);
280 hfsplus_file_truncate(inode
);
281 if (inode
->i_flags
& S_DEAD
) {
282 hfsplus_delete_cat(inode
->i_ino
,
283 HFSPLUS_SB(sb
)->hidden_dir
, NULL
);
284 hfsplus_delete_inode(inode
);
286 mutex_unlock(&inode
->i_mutex
);
291 static int hfsplus_setattr(struct dentry
*dentry
, struct iattr
*attr
)
293 struct inode
*inode
= dentry
->d_inode
;
296 error
= inode_change_ok(inode
, attr
);
300 if ((attr
->ia_valid
& ATTR_SIZE
) &&
301 attr
->ia_size
!= i_size_read(inode
)) {
302 inode_dio_wait(inode
);
304 error
= vmtruncate(inode
, attr
->ia_size
);
309 setattr_copy(inode
, attr
);
310 mark_inode_dirty(inode
);
314 int hfsplus_file_fsync(struct file
*file
, loff_t start
, loff_t end
,
317 struct inode
*inode
= file
->f_mapping
->host
;
318 struct hfsplus_inode_info
*hip
= HFSPLUS_I(inode
);
319 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(inode
->i_sb
);
320 int error
= 0, error2
;
322 error
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
325 mutex_lock(&inode
->i_mutex
);
328 * Sync inode metadata into the catalog and extent trees.
330 sync_inode_metadata(inode
, 1);
333 * And explicitly write out the btrees.
335 if (test_and_clear_bit(HFSPLUS_I_CAT_DIRTY
, &hip
->flags
))
336 error
= filemap_write_and_wait(sbi
->cat_tree
->inode
->i_mapping
);
338 if (test_and_clear_bit(HFSPLUS_I_EXT_DIRTY
, &hip
->flags
)) {
340 filemap_write_and_wait(sbi
->ext_tree
->inode
->i_mapping
);
345 if (test_and_clear_bit(HFSPLUS_I_ALLOC_DIRTY
, &hip
->flags
)) {
346 error2
= filemap_write_and_wait(sbi
->alloc_file
->i_mapping
);
351 if (!test_bit(HFSPLUS_SB_NOBARRIER
, &sbi
->flags
))
352 blkdev_issue_flush(inode
->i_sb
->s_bdev
, GFP_KERNEL
, NULL
);
354 mutex_unlock(&inode
->i_mutex
);
359 static const struct inode_operations hfsplus_file_inode_operations
= {
360 .lookup
= hfsplus_file_lookup
,
361 .truncate
= hfsplus_file_truncate
,
362 .setattr
= hfsplus_setattr
,
363 .setxattr
= hfsplus_setxattr
,
364 .getxattr
= hfsplus_getxattr
,
365 .listxattr
= hfsplus_listxattr
,
368 static const struct file_operations hfsplus_file_operations
= {
369 .llseek
= generic_file_llseek
,
370 .read
= do_sync_read
,
371 .aio_read
= generic_file_aio_read
,
372 .write
= do_sync_write
,
373 .aio_write
= generic_file_aio_write
,
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
,
382 struct inode
*hfsplus_new_inode(struct super_block
*sb
, umode_t mode
)
384 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
385 struct inode
*inode
= new_inode(sb
);
386 struct hfsplus_inode_info
*hip
;
391 inode
->i_ino
= sbi
->next_cnid
++;
392 inode
->i_mode
= mode
;
393 inode
->i_uid
= current_fsuid();
394 inode
->i_gid
= current_fsgid();
396 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
398 hip
= HFSPLUS_I(inode
);
399 INIT_LIST_HEAD(&hip
->open_dir_list
);
400 mutex_init(&hip
->extents_lock
);
401 atomic_set(&hip
->opencnt
, 0);
402 hip
->extent_state
= 0;
405 memset(hip
->first_extents
, 0, sizeof(hfsplus_extent_rec
));
406 memset(hip
->cached_extents
, 0, sizeof(hfsplus_extent_rec
));
407 hip
->alloc_blocks
= 0;
408 hip
->first_blocks
= 0;
409 hip
->cached_start
= 0;
410 hip
->cached_blocks
= 0;
413 hip
->rsrc_inode
= NULL
;
414 if (S_ISDIR(inode
->i_mode
)) {
417 inode
->i_op
= &hfsplus_dir_inode_operations
;
418 inode
->i_fop
= &hfsplus_dir_operations
;
419 } else if (S_ISREG(inode
->i_mode
)) {
421 inode
->i_op
= &hfsplus_file_inode_operations
;
422 inode
->i_fop
= &hfsplus_file_operations
;
423 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
424 hip
->clump_blocks
= sbi
->data_clump_blocks
;
425 } else if (S_ISLNK(inode
->i_mode
)) {
427 inode
->i_op
= &page_symlink_inode_operations
;
428 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
429 hip
->clump_blocks
= 1;
432 insert_inode_hash(inode
);
433 mark_inode_dirty(inode
);
434 hfsplus_mark_mdb_dirty(sb
);
439 void hfsplus_delete_inode(struct inode
*inode
)
441 struct super_block
*sb
= inode
->i_sb
;
443 if (S_ISDIR(inode
->i_mode
)) {
444 HFSPLUS_SB(sb
)->folder_count
--;
445 hfsplus_mark_mdb_dirty(sb
);
448 HFSPLUS_SB(sb
)->file_count
--;
449 if (S_ISREG(inode
->i_mode
)) {
450 if (!inode
->i_nlink
) {
452 hfsplus_file_truncate(inode
);
454 } else if (S_ISLNK(inode
->i_mode
)) {
456 hfsplus_file_truncate(inode
);
458 hfsplus_mark_mdb_dirty(sb
);
461 void hfsplus_inode_read_fork(struct inode
*inode
, struct hfsplus_fork_raw
*fork
)
463 struct super_block
*sb
= inode
->i_sb
;
464 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
465 struct hfsplus_inode_info
*hip
= HFSPLUS_I(inode
);
469 memcpy(&hip
->first_extents
, &fork
->extents
, sizeof(hfsplus_extent_rec
));
470 for (count
= 0, i
= 0; i
< 8; i
++)
471 count
+= be32_to_cpu(fork
->extents
[i
].block_count
);
472 hip
->first_blocks
= count
;
473 memset(hip
->cached_extents
, 0, sizeof(hfsplus_extent_rec
));
474 hip
->cached_start
= 0;
475 hip
->cached_blocks
= 0;
477 hip
->alloc_blocks
= be32_to_cpu(fork
->total_blocks
);
478 hip
->phys_size
= inode
->i_size
= be64_to_cpu(fork
->total_size
);
480 (inode
->i_size
+ sb
->s_blocksize
- 1) >> sb
->s_blocksize_bits
;
481 inode_set_bytes(inode
, hip
->fs_blocks
<< sb
->s_blocksize_bits
);
483 be32_to_cpu(fork
->clump_size
) >> sbi
->alloc_blksz_shift
;
484 if (!hip
->clump_blocks
) {
485 hip
->clump_blocks
= HFSPLUS_IS_RSRC(inode
) ?
486 sbi
->rsrc_clump_blocks
:
487 sbi
->data_clump_blocks
;
491 void hfsplus_inode_write_fork(struct inode
*inode
,
492 struct hfsplus_fork_raw
*fork
)
494 memcpy(&fork
->extents
, &HFSPLUS_I(inode
)->first_extents
,
495 sizeof(hfsplus_extent_rec
));
496 fork
->total_size
= cpu_to_be64(inode
->i_size
);
497 fork
->total_blocks
= cpu_to_be32(HFSPLUS_I(inode
)->alloc_blocks
);
500 int hfsplus_cat_read_inode(struct inode
*inode
, struct hfs_find_data
*fd
)
502 hfsplus_cat_entry entry
;
506 type
= hfs_bnode_read_u16(fd
->bnode
, fd
->entryoffset
);
508 HFSPLUS_I(inode
)->linkid
= 0;
509 if (type
== HFSPLUS_FOLDER
) {
510 struct hfsplus_cat_folder
*folder
= &entry
.folder
;
512 if (fd
->entrylength
< sizeof(struct hfsplus_cat_folder
))
514 hfs_bnode_read(fd
->bnode
, &entry
, fd
->entryoffset
,
515 sizeof(struct hfsplus_cat_folder
));
516 hfsplus_get_perms(inode
, &folder
->permissions
, 1);
518 inode
->i_size
= 2 + be32_to_cpu(folder
->valence
);
519 inode
->i_atime
= hfsp_mt2ut(folder
->access_date
);
520 inode
->i_mtime
= hfsp_mt2ut(folder
->content_mod_date
);
521 inode
->i_ctime
= hfsp_mt2ut(folder
->attribute_mod_date
);
522 HFSPLUS_I(inode
)->create_date
= folder
->create_date
;
523 HFSPLUS_I(inode
)->fs_blocks
= 0;
524 inode
->i_op
= &hfsplus_dir_inode_operations
;
525 inode
->i_fop
= &hfsplus_dir_operations
;
526 } else if (type
== HFSPLUS_FILE
) {
527 struct hfsplus_cat_file
*file
= &entry
.file
;
529 if (fd
->entrylength
< sizeof(struct hfsplus_cat_file
))
531 hfs_bnode_read(fd
->bnode
, &entry
, fd
->entryoffset
,
532 sizeof(struct hfsplus_cat_file
));
534 hfsplus_inode_read_fork(inode
, HFSPLUS_IS_RSRC(inode
) ?
535 &file
->rsrc_fork
: &file
->data_fork
);
536 hfsplus_get_perms(inode
, &file
->permissions
, 0);
538 if (S_ISREG(inode
->i_mode
)) {
539 if (file
->permissions
.dev
)
541 be32_to_cpu(file
->permissions
.dev
));
542 inode
->i_op
= &hfsplus_file_inode_operations
;
543 inode
->i_fop
= &hfsplus_file_operations
;
544 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
545 } else if (S_ISLNK(inode
->i_mode
)) {
546 inode
->i_op
= &page_symlink_inode_operations
;
547 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
549 init_special_inode(inode
, inode
->i_mode
,
550 be32_to_cpu(file
->permissions
.dev
));
552 inode
->i_atime
= hfsp_mt2ut(file
->access_date
);
553 inode
->i_mtime
= hfsp_mt2ut(file
->content_mod_date
);
554 inode
->i_ctime
= hfsp_mt2ut(file
->attribute_mod_date
);
555 HFSPLUS_I(inode
)->create_date
= file
->create_date
;
557 printk(KERN_ERR
"hfs: bad catalog entry used to create inode\n");
563 int hfsplus_cat_write_inode(struct inode
*inode
)
565 struct inode
*main_inode
= inode
;
566 struct hfs_find_data fd
;
567 hfsplus_cat_entry entry
;
569 if (HFSPLUS_IS_RSRC(inode
))
570 main_inode
= HFSPLUS_I(inode
)->rsrc_inode
;
572 if (!main_inode
->i_nlink
)
575 if (hfs_find_init(HFSPLUS_SB(main_inode
->i_sb
)->cat_tree
, &fd
))
579 if (hfsplus_find_cat(main_inode
->i_sb
, main_inode
->i_ino
, &fd
))
583 if (S_ISDIR(main_inode
->i_mode
)) {
584 struct hfsplus_cat_folder
*folder
= &entry
.folder
;
586 if (fd
.entrylength
< sizeof(struct hfsplus_cat_folder
))
588 hfs_bnode_read(fd
.bnode
, &entry
, fd
.entryoffset
,
589 sizeof(struct hfsplus_cat_folder
));
590 /* simple node checks? */
591 hfsplus_cat_set_perms(inode
, &folder
->permissions
);
592 folder
->access_date
= hfsp_ut2mt(inode
->i_atime
);
593 folder
->content_mod_date
= hfsp_ut2mt(inode
->i_mtime
);
594 folder
->attribute_mod_date
= hfsp_ut2mt(inode
->i_ctime
);
595 folder
->valence
= cpu_to_be32(inode
->i_size
- 2);
596 hfs_bnode_write(fd
.bnode
, &entry
, fd
.entryoffset
,
597 sizeof(struct hfsplus_cat_folder
));
598 } else if (HFSPLUS_IS_RSRC(inode
)) {
599 struct hfsplus_cat_file
*file
= &entry
.file
;
600 hfs_bnode_read(fd
.bnode
, &entry
, fd
.entryoffset
,
601 sizeof(struct hfsplus_cat_file
));
602 hfsplus_inode_write_fork(inode
, &file
->rsrc_fork
);
603 hfs_bnode_write(fd
.bnode
, &entry
, fd
.entryoffset
,
604 sizeof(struct hfsplus_cat_file
));
606 struct hfsplus_cat_file
*file
= &entry
.file
;
608 if (fd
.entrylength
< sizeof(struct hfsplus_cat_file
))
610 hfs_bnode_read(fd
.bnode
, &entry
, fd
.entryoffset
,
611 sizeof(struct hfsplus_cat_file
));
612 hfsplus_inode_write_fork(inode
, &file
->data_fork
);
613 hfsplus_cat_set_perms(inode
, &file
->permissions
);
614 if (HFSPLUS_FLG_IMMUTABLE
&
615 (file
->permissions
.rootflags
|
616 file
->permissions
.userflags
))
617 file
->flags
|= cpu_to_be16(HFSPLUS_FILE_LOCKED
);
619 file
->flags
&= cpu_to_be16(~HFSPLUS_FILE_LOCKED
);
620 file
->access_date
= hfsp_ut2mt(inode
->i_atime
);
621 file
->content_mod_date
= hfsp_ut2mt(inode
->i_mtime
);
622 file
->attribute_mod_date
= hfsp_ut2mt(inode
->i_ctime
);
623 hfs_bnode_write(fd
.bnode
, &entry
, fd
.entryoffset
,
624 sizeof(struct hfsplus_cat_file
));
627 set_bit(HFSPLUS_I_CAT_DIRTY
, &HFSPLUS_I(inode
)->flags
);