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>
17 #include <linux/aio.h>
19 #include "hfsplus_fs.h"
20 #include "hfsplus_raw.h"
24 static int hfsplus_readpage(struct file
*file
, struct page
*page
)
26 return block_read_full_page(page
, hfsplus_get_block
);
29 static int hfsplus_writepage(struct page
*page
, struct writeback_control
*wbc
)
31 return block_write_full_page(page
, hfsplus_get_block
, wbc
);
34 static void hfsplus_write_failed(struct address_space
*mapping
, loff_t to
)
36 struct inode
*inode
= mapping
->host
;
38 if (to
> inode
->i_size
) {
39 truncate_pagecache(inode
, inode
->i_size
);
40 hfsplus_file_truncate(inode
);
44 static int hfsplus_write_begin(struct file
*file
, struct address_space
*mapping
,
45 loff_t pos
, unsigned len
, unsigned flags
,
46 struct page
**pagep
, void **fsdata
)
51 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
53 &HFSPLUS_I(mapping
->host
)->phys_size
);
55 hfsplus_write_failed(mapping
, pos
+ len
);
60 static sector_t
hfsplus_bmap(struct address_space
*mapping
, sector_t block
)
62 return generic_block_bmap(mapping
, block
, hfsplus_get_block
);
65 static int hfsplus_releasepage(struct page
*page
, gfp_t mask
)
67 struct inode
*inode
= page
->mapping
->host
;
68 struct super_block
*sb
= inode
->i_sb
;
69 struct hfs_btree
*tree
;
70 struct hfs_bnode
*node
;
74 switch (inode
->i_ino
) {
75 case HFSPLUS_EXT_CNID
:
76 tree
= HFSPLUS_SB(sb
)->ext_tree
;
78 case HFSPLUS_CAT_CNID
:
79 tree
= HFSPLUS_SB(sb
)->cat_tree
;
81 case HFSPLUS_ATTR_CNID
:
82 tree
= HFSPLUS_SB(sb
)->attr_tree
;
90 if (tree
->node_size
>= PAGE_CACHE_SIZE
) {
92 (tree
->node_size_shift
- PAGE_CACHE_SHIFT
);
93 spin_lock(&tree
->hash_lock
);
94 node
= hfs_bnode_findhash(tree
, nidx
);
97 else if (atomic_read(&node
->refcnt
))
100 hfs_bnode_unhash(node
);
101 hfs_bnode_free(node
);
103 spin_unlock(&tree
->hash_lock
);
105 nidx
= page
->index
<<
106 (PAGE_CACHE_SHIFT
- tree
->node_size_shift
);
107 i
= 1 << (PAGE_CACHE_SHIFT
- tree
->node_size_shift
);
108 spin_lock(&tree
->hash_lock
);
110 node
= hfs_bnode_findhash(tree
, nidx
++);
113 if (atomic_read(&node
->refcnt
)) {
117 hfs_bnode_unhash(node
);
118 hfs_bnode_free(node
);
119 } while (--i
&& nidx
< tree
->node_count
);
120 spin_unlock(&tree
->hash_lock
);
122 return res
? try_to_free_buffers(page
) : 0;
125 static ssize_t
hfsplus_direct_IO(int rw
, struct kiocb
*iocb
,
126 const struct iovec
*iov
, loff_t offset
, unsigned long nr_segs
)
128 struct file
*file
= iocb
->ki_filp
;
129 struct address_space
*mapping
= file
->f_mapping
;
130 struct inode
*inode
= file_inode(file
)->i_mapping
->host
;
133 ret
= blockdev_direct_IO(rw
, iocb
, inode
, iov
, offset
, nr_segs
,
137 * In case of error extending write may have instantiated a few
138 * blocks outside i_size. Trim these off again.
140 if (unlikely((rw
& WRITE
) && ret
< 0)) {
141 loff_t isize
= i_size_read(inode
);
142 loff_t end
= offset
+ iov_length(iov
, nr_segs
);
145 hfsplus_write_failed(mapping
, end
);
151 static int hfsplus_writepages(struct address_space
*mapping
,
152 struct writeback_control
*wbc
)
154 return mpage_writepages(mapping
, wbc
, hfsplus_get_block
);
157 const struct address_space_operations hfsplus_btree_aops
= {
158 .readpage
= hfsplus_readpage
,
159 .writepage
= hfsplus_writepage
,
160 .write_begin
= hfsplus_write_begin
,
161 .write_end
= generic_write_end
,
162 .bmap
= hfsplus_bmap
,
163 .releasepage
= hfsplus_releasepage
,
166 const struct address_space_operations hfsplus_aops
= {
167 .readpage
= hfsplus_readpage
,
168 .writepage
= hfsplus_writepage
,
169 .write_begin
= hfsplus_write_begin
,
170 .write_end
= generic_write_end
,
171 .bmap
= hfsplus_bmap
,
172 .direct_IO
= hfsplus_direct_IO
,
173 .writepages
= hfsplus_writepages
,
176 const struct dentry_operations hfsplus_dentry_operations
= {
177 .d_hash
= hfsplus_hash_dentry
,
178 .d_compare
= hfsplus_compare_dentry
,
181 static void hfsplus_get_perms(struct inode
*inode
,
182 struct hfsplus_perm
*perms
, int dir
)
184 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(inode
->i_sb
);
187 mode
= be16_to_cpu(perms
->mode
);
189 i_uid_write(inode
, be32_to_cpu(perms
->owner
));
190 if (!i_uid_read(inode
) && !mode
)
191 inode
->i_uid
= sbi
->uid
;
193 i_gid_write(inode
, be32_to_cpu(perms
->group
));
194 if (!i_gid_read(inode
) && !mode
)
195 inode
->i_gid
= sbi
->gid
;
198 mode
= mode
? (mode
& S_IALLUGO
) : (S_IRWXUGO
& ~(sbi
->umask
));
201 mode
= S_IFREG
| ((S_IRUGO
|S_IWUGO
) & ~(sbi
->umask
));
202 inode
->i_mode
= mode
;
204 HFSPLUS_I(inode
)->userflags
= perms
->userflags
;
205 if (perms
->rootflags
& HFSPLUS_FLG_IMMUTABLE
)
206 inode
->i_flags
|= S_IMMUTABLE
;
208 inode
->i_flags
&= ~S_IMMUTABLE
;
209 if (perms
->rootflags
& HFSPLUS_FLG_APPEND
)
210 inode
->i_flags
|= S_APPEND
;
212 inode
->i_flags
&= ~S_APPEND
;
215 static int hfsplus_file_open(struct inode
*inode
, struct file
*file
)
217 if (HFSPLUS_IS_RSRC(inode
))
218 inode
= HFSPLUS_I(inode
)->rsrc_inode
;
219 if (!(file
->f_flags
& O_LARGEFILE
) && i_size_read(inode
) > MAX_NON_LFS
)
221 atomic_inc(&HFSPLUS_I(inode
)->opencnt
);
225 static int hfsplus_file_release(struct inode
*inode
, struct file
*file
)
227 struct super_block
*sb
= inode
->i_sb
;
229 if (HFSPLUS_IS_RSRC(inode
))
230 inode
= HFSPLUS_I(inode
)->rsrc_inode
;
231 if (atomic_dec_and_test(&HFSPLUS_I(inode
)->opencnt
)) {
232 mutex_lock(&inode
->i_mutex
);
233 hfsplus_file_truncate(inode
);
234 if (inode
->i_flags
& S_DEAD
) {
235 hfsplus_delete_cat(inode
->i_ino
,
236 HFSPLUS_SB(sb
)->hidden_dir
, NULL
);
237 hfsplus_delete_inode(inode
);
239 mutex_unlock(&inode
->i_mutex
);
244 static int hfsplus_setattr(struct dentry
*dentry
, struct iattr
*attr
)
246 struct inode
*inode
= dentry
->d_inode
;
249 error
= inode_change_ok(inode
, attr
);
253 if ((attr
->ia_valid
& ATTR_SIZE
) &&
254 attr
->ia_size
!= i_size_read(inode
)) {
255 inode_dio_wait(inode
);
256 truncate_setsize(inode
, attr
->ia_size
);
257 hfsplus_file_truncate(inode
);
260 setattr_copy(inode
, attr
);
261 mark_inode_dirty(inode
);
263 if (attr
->ia_valid
& ATTR_MODE
) {
264 error
= posix_acl_chmod(inode
, inode
->i_mode
);
272 int hfsplus_file_fsync(struct file
*file
, loff_t start
, loff_t end
,
275 struct inode
*inode
= file
->f_mapping
->host
;
276 struct hfsplus_inode_info
*hip
= HFSPLUS_I(inode
);
277 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(inode
->i_sb
);
278 int error
= 0, error2
;
280 error
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
283 mutex_lock(&inode
->i_mutex
);
286 * Sync inode metadata into the catalog and extent trees.
288 sync_inode_metadata(inode
, 1);
291 * And explicitly write out the btrees.
293 if (test_and_clear_bit(HFSPLUS_I_CAT_DIRTY
, &hip
->flags
))
294 error
= filemap_write_and_wait(sbi
->cat_tree
->inode
->i_mapping
);
296 if (test_and_clear_bit(HFSPLUS_I_EXT_DIRTY
, &hip
->flags
)) {
298 filemap_write_and_wait(sbi
->ext_tree
->inode
->i_mapping
);
303 if (test_and_clear_bit(HFSPLUS_I_ATTR_DIRTY
, &hip
->flags
)) {
304 if (sbi
->attr_tree
) {
306 filemap_write_and_wait(
307 sbi
->attr_tree
->inode
->i_mapping
);
311 pr_err("sync non-existent attributes tree\n");
315 if (test_and_clear_bit(HFSPLUS_I_ALLOC_DIRTY
, &hip
->flags
)) {
316 error2
= filemap_write_and_wait(sbi
->alloc_file
->i_mapping
);
321 if (!test_bit(HFSPLUS_SB_NOBARRIER
, &sbi
->flags
))
322 blkdev_issue_flush(inode
->i_sb
->s_bdev
, GFP_KERNEL
, NULL
);
324 mutex_unlock(&inode
->i_mutex
);
329 static const struct inode_operations hfsplus_file_inode_operations
= {
330 .setattr
= hfsplus_setattr
,
331 .setxattr
= generic_setxattr
,
332 .getxattr
= generic_getxattr
,
333 .listxattr
= hfsplus_listxattr
,
334 .removexattr
= generic_removexattr
,
335 #ifdef CONFIG_HFSPLUS_FS_POSIX_ACL
336 .get_acl
= hfsplus_get_posix_acl
,
337 .set_acl
= hfsplus_set_posix_acl
,
341 static const struct file_operations hfsplus_file_operations
= {
342 .llseek
= generic_file_llseek
,
343 .read
= do_sync_read
,
344 .aio_read
= generic_file_aio_read
,
345 .write
= do_sync_write
,
346 .aio_write
= generic_file_aio_write
,
347 .mmap
= generic_file_mmap
,
348 .splice_read
= generic_file_splice_read
,
349 .fsync
= hfsplus_file_fsync
,
350 .open
= hfsplus_file_open
,
351 .release
= hfsplus_file_release
,
352 .unlocked_ioctl
= hfsplus_ioctl
,
355 struct inode
*hfsplus_new_inode(struct super_block
*sb
, umode_t mode
)
357 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
358 struct inode
*inode
= new_inode(sb
);
359 struct hfsplus_inode_info
*hip
;
364 inode
->i_ino
= sbi
->next_cnid
++;
365 inode
->i_mode
= mode
;
366 inode
->i_uid
= current_fsuid();
367 inode
->i_gid
= current_fsgid();
369 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
371 hip
= HFSPLUS_I(inode
);
372 INIT_LIST_HEAD(&hip
->open_dir_list
);
373 mutex_init(&hip
->extents_lock
);
374 atomic_set(&hip
->opencnt
, 0);
375 hip
->extent_state
= 0;
379 memset(hip
->first_extents
, 0, sizeof(hfsplus_extent_rec
));
380 memset(hip
->cached_extents
, 0, sizeof(hfsplus_extent_rec
));
381 hip
->alloc_blocks
= 0;
382 hip
->first_blocks
= 0;
383 hip
->cached_start
= 0;
384 hip
->cached_blocks
= 0;
387 hip
->rsrc_inode
= NULL
;
388 if (S_ISDIR(inode
->i_mode
)) {
391 inode
->i_op
= &hfsplus_dir_inode_operations
;
392 inode
->i_fop
= &hfsplus_dir_operations
;
393 } else if (S_ISREG(inode
->i_mode
)) {
395 inode
->i_op
= &hfsplus_file_inode_operations
;
396 inode
->i_fop
= &hfsplus_file_operations
;
397 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
398 hip
->clump_blocks
= sbi
->data_clump_blocks
;
399 } else if (S_ISLNK(inode
->i_mode
)) {
401 inode
->i_op
= &page_symlink_inode_operations
;
402 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
403 hip
->clump_blocks
= 1;
406 insert_inode_hash(inode
);
407 mark_inode_dirty(inode
);
408 hfsplus_mark_mdb_dirty(sb
);
413 void hfsplus_delete_inode(struct inode
*inode
)
415 struct super_block
*sb
= inode
->i_sb
;
417 if (S_ISDIR(inode
->i_mode
)) {
418 HFSPLUS_SB(sb
)->folder_count
--;
419 hfsplus_mark_mdb_dirty(sb
);
422 HFSPLUS_SB(sb
)->file_count
--;
423 if (S_ISREG(inode
->i_mode
)) {
424 if (!inode
->i_nlink
) {
426 hfsplus_file_truncate(inode
);
428 } else if (S_ISLNK(inode
->i_mode
)) {
430 hfsplus_file_truncate(inode
);
432 hfsplus_mark_mdb_dirty(sb
);
435 void hfsplus_inode_read_fork(struct inode
*inode
, struct hfsplus_fork_raw
*fork
)
437 struct super_block
*sb
= inode
->i_sb
;
438 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
439 struct hfsplus_inode_info
*hip
= HFSPLUS_I(inode
);
443 memcpy(&hip
->first_extents
, &fork
->extents
, sizeof(hfsplus_extent_rec
));
444 for (count
= 0, i
= 0; i
< 8; i
++)
445 count
+= be32_to_cpu(fork
->extents
[i
].block_count
);
446 hip
->first_blocks
= count
;
447 memset(hip
->cached_extents
, 0, sizeof(hfsplus_extent_rec
));
448 hip
->cached_start
= 0;
449 hip
->cached_blocks
= 0;
451 hip
->alloc_blocks
= be32_to_cpu(fork
->total_blocks
);
452 hip
->phys_size
= inode
->i_size
= be64_to_cpu(fork
->total_size
);
454 (inode
->i_size
+ sb
->s_blocksize
- 1) >> sb
->s_blocksize_bits
;
455 inode_set_bytes(inode
, hip
->fs_blocks
<< sb
->s_blocksize_bits
);
457 be32_to_cpu(fork
->clump_size
) >> sbi
->alloc_blksz_shift
;
458 if (!hip
->clump_blocks
) {
459 hip
->clump_blocks
= HFSPLUS_IS_RSRC(inode
) ?
460 sbi
->rsrc_clump_blocks
:
461 sbi
->data_clump_blocks
;
465 void hfsplus_inode_write_fork(struct inode
*inode
,
466 struct hfsplus_fork_raw
*fork
)
468 memcpy(&fork
->extents
, &HFSPLUS_I(inode
)->first_extents
,
469 sizeof(hfsplus_extent_rec
));
470 fork
->total_size
= cpu_to_be64(inode
->i_size
);
471 fork
->total_blocks
= cpu_to_be32(HFSPLUS_I(inode
)->alloc_blocks
);
474 int hfsplus_cat_read_inode(struct inode
*inode
, struct hfs_find_data
*fd
)
476 hfsplus_cat_entry entry
;
480 type
= hfs_bnode_read_u16(fd
->bnode
, fd
->entryoffset
);
482 HFSPLUS_I(inode
)->linkid
= 0;
483 if (type
== HFSPLUS_FOLDER
) {
484 struct hfsplus_cat_folder
*folder
= &entry
.folder
;
486 if (fd
->entrylength
< sizeof(struct hfsplus_cat_folder
))
488 hfs_bnode_read(fd
->bnode
, &entry
, fd
->entryoffset
,
489 sizeof(struct hfsplus_cat_folder
));
490 hfsplus_get_perms(inode
, &folder
->permissions
, 1);
492 inode
->i_size
= 2 + be32_to_cpu(folder
->valence
);
493 inode
->i_atime
= hfsp_mt2ut(folder
->access_date
);
494 inode
->i_mtime
= hfsp_mt2ut(folder
->content_mod_date
);
495 inode
->i_ctime
= hfsp_mt2ut(folder
->attribute_mod_date
);
496 HFSPLUS_I(inode
)->create_date
= folder
->create_date
;
497 HFSPLUS_I(inode
)->fs_blocks
= 0;
498 if (folder
->flags
& cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT
)) {
499 HFSPLUS_I(inode
)->subfolders
=
500 be32_to_cpu(folder
->subfolders
);
502 inode
->i_op
= &hfsplus_dir_inode_operations
;
503 inode
->i_fop
= &hfsplus_dir_operations
;
504 } else if (type
== HFSPLUS_FILE
) {
505 struct hfsplus_cat_file
*file
= &entry
.file
;
507 if (fd
->entrylength
< sizeof(struct hfsplus_cat_file
))
509 hfs_bnode_read(fd
->bnode
, &entry
, fd
->entryoffset
,
510 sizeof(struct hfsplus_cat_file
));
512 hfsplus_inode_read_fork(inode
, HFSPLUS_IS_RSRC(inode
) ?
513 &file
->rsrc_fork
: &file
->data_fork
);
514 hfsplus_get_perms(inode
, &file
->permissions
, 0);
516 if (S_ISREG(inode
->i_mode
)) {
517 if (file
->permissions
.dev
)
519 be32_to_cpu(file
->permissions
.dev
));
520 inode
->i_op
= &hfsplus_file_inode_operations
;
521 inode
->i_fop
= &hfsplus_file_operations
;
522 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
523 } else if (S_ISLNK(inode
->i_mode
)) {
524 inode
->i_op
= &page_symlink_inode_operations
;
525 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
527 init_special_inode(inode
, inode
->i_mode
,
528 be32_to_cpu(file
->permissions
.dev
));
530 inode
->i_atime
= hfsp_mt2ut(file
->access_date
);
531 inode
->i_mtime
= hfsp_mt2ut(file
->content_mod_date
);
532 inode
->i_ctime
= hfsp_mt2ut(file
->attribute_mod_date
);
533 HFSPLUS_I(inode
)->create_date
= file
->create_date
;
535 pr_err("bad catalog entry used to create inode\n");
541 int hfsplus_cat_write_inode(struct inode
*inode
)
543 struct inode
*main_inode
= inode
;
544 struct hfs_find_data fd
;
545 hfsplus_cat_entry entry
;
547 if (HFSPLUS_IS_RSRC(inode
))
548 main_inode
= HFSPLUS_I(inode
)->rsrc_inode
;
550 if (!main_inode
->i_nlink
)
553 if (hfs_find_init(HFSPLUS_SB(main_inode
->i_sb
)->cat_tree
, &fd
))
557 if (hfsplus_find_cat(main_inode
->i_sb
, main_inode
->i_ino
, &fd
))
561 if (S_ISDIR(main_inode
->i_mode
)) {
562 struct hfsplus_cat_folder
*folder
= &entry
.folder
;
564 if (fd
.entrylength
< sizeof(struct hfsplus_cat_folder
))
566 hfs_bnode_read(fd
.bnode
, &entry
, fd
.entryoffset
,
567 sizeof(struct hfsplus_cat_folder
));
568 /* simple node checks? */
569 hfsplus_cat_set_perms(inode
, &folder
->permissions
);
570 folder
->access_date
= hfsp_ut2mt(inode
->i_atime
);
571 folder
->content_mod_date
= hfsp_ut2mt(inode
->i_mtime
);
572 folder
->attribute_mod_date
= hfsp_ut2mt(inode
->i_ctime
);
573 folder
->valence
= cpu_to_be32(inode
->i_size
- 2);
574 if (folder
->flags
& cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT
)) {
576 cpu_to_be32(HFSPLUS_I(inode
)->subfolders
);
578 hfs_bnode_write(fd
.bnode
, &entry
, fd
.entryoffset
,
579 sizeof(struct hfsplus_cat_folder
));
580 } else if (HFSPLUS_IS_RSRC(inode
)) {
581 struct hfsplus_cat_file
*file
= &entry
.file
;
582 hfs_bnode_read(fd
.bnode
, &entry
, fd
.entryoffset
,
583 sizeof(struct hfsplus_cat_file
));
584 hfsplus_inode_write_fork(inode
, &file
->rsrc_fork
);
585 hfs_bnode_write(fd
.bnode
, &entry
, fd
.entryoffset
,
586 sizeof(struct hfsplus_cat_file
));
588 struct hfsplus_cat_file
*file
= &entry
.file
;
590 if (fd
.entrylength
< sizeof(struct hfsplus_cat_file
))
592 hfs_bnode_read(fd
.bnode
, &entry
, fd
.entryoffset
,
593 sizeof(struct hfsplus_cat_file
));
594 hfsplus_inode_write_fork(inode
, &file
->data_fork
);
595 hfsplus_cat_set_perms(inode
, &file
->permissions
);
596 if (HFSPLUS_FLG_IMMUTABLE
&
597 (file
->permissions
.rootflags
|
598 file
->permissions
.userflags
))
599 file
->flags
|= cpu_to_be16(HFSPLUS_FILE_LOCKED
);
601 file
->flags
&= cpu_to_be16(~HFSPLUS_FILE_LOCKED
);
602 file
->access_date
= hfsp_ut2mt(inode
->i_atime
);
603 file
->content_mod_date
= hfsp_ut2mt(inode
->i_mtime
);
604 file
->attribute_mod_date
= hfsp_ut2mt(inode
->i_ctime
);
605 hfs_bnode_write(fd
.bnode
, &entry
, fd
.entryoffset
,
606 sizeof(struct hfsplus_cat_file
));
609 set_bit(HFSPLUS_I_CAT_DIRTY
, &HFSPLUS_I(inode
)->flags
);