2 * linux/fs/hfsplus/super.c
5 * Brad Boyer (flar@allandria.com)
6 * (C) 2003 Ardis Technologies <roman@ardistech.com>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/pagemap.h>
13 #include <linux/blkdev.h>
15 #include <linux/slab.h>
16 #include <linux/vfs.h>
17 #include <linux/nls.h>
19 static struct inode
*hfsplus_alloc_inode(struct super_block
*sb
);
20 static void hfsplus_destroy_inode(struct inode
*inode
);
22 #include "hfsplus_fs.h"
24 static int hfsplus_system_read_inode(struct inode
*inode
)
26 struct hfsplus_vh
*vhdr
= HFSPLUS_SB(inode
->i_sb
)->s_vhdr
;
28 switch (inode
->i_ino
) {
29 case HFSPLUS_EXT_CNID
:
30 hfsplus_inode_read_fork(inode
, &vhdr
->ext_file
);
31 inode
->i_mapping
->a_ops
= &hfsplus_btree_aops
;
33 case HFSPLUS_CAT_CNID
:
34 hfsplus_inode_read_fork(inode
, &vhdr
->cat_file
);
35 inode
->i_mapping
->a_ops
= &hfsplus_btree_aops
;
37 case HFSPLUS_ALLOC_CNID
:
38 hfsplus_inode_read_fork(inode
, &vhdr
->alloc_file
);
39 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
41 case HFSPLUS_START_CNID
:
42 hfsplus_inode_read_fork(inode
, &vhdr
->start_file
);
44 case HFSPLUS_ATTR_CNID
:
45 hfsplus_inode_read_fork(inode
, &vhdr
->attr_file
);
46 inode
->i_mapping
->a_ops
= &hfsplus_btree_aops
;
55 struct inode
*hfsplus_iget(struct super_block
*sb
, unsigned long ino
)
57 struct hfs_find_data fd
;
61 inode
= iget_locked(sb
, ino
);
63 return ERR_PTR(-ENOMEM
);
64 if (!(inode
->i_state
& I_NEW
))
67 INIT_LIST_HEAD(&HFSPLUS_I(inode
)->open_dir_list
);
68 mutex_init(&HFSPLUS_I(inode
)->extents_lock
);
69 HFSPLUS_I(inode
)->flags
= 0;
70 HFSPLUS_I(inode
)->extent_state
= 0;
71 HFSPLUS_I(inode
)->rsrc_inode
= NULL
;
72 atomic_set(&HFSPLUS_I(inode
)->opencnt
, 0);
74 if (inode
->i_ino
>= HFSPLUS_FIRSTUSER_CNID
||
75 inode
->i_ino
== HFSPLUS_ROOT_CNID
) {
76 hfs_find_init(HFSPLUS_SB(inode
->i_sb
)->cat_tree
, &fd
);
77 err
= hfsplus_find_cat(inode
->i_sb
, inode
->i_ino
, &fd
);
79 err
= hfsplus_cat_read_inode(inode
, &fd
);
82 err
= hfsplus_system_read_inode(inode
);
90 unlock_new_inode(inode
);
94 static int hfsplus_system_write_inode(struct inode
*inode
)
96 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(inode
->i_sb
);
97 struct hfsplus_vh
*vhdr
= sbi
->s_vhdr
;
98 struct hfsplus_fork_raw
*fork
;
99 struct hfs_btree
*tree
= NULL
;
101 switch (inode
->i_ino
) {
102 case HFSPLUS_EXT_CNID
:
103 fork
= &vhdr
->ext_file
;
104 tree
= sbi
->ext_tree
;
106 case HFSPLUS_CAT_CNID
:
107 fork
= &vhdr
->cat_file
;
108 tree
= sbi
->cat_tree
;
110 case HFSPLUS_ALLOC_CNID
:
111 fork
= &vhdr
->alloc_file
;
113 case HFSPLUS_START_CNID
:
114 fork
= &vhdr
->start_file
;
116 case HFSPLUS_ATTR_CNID
:
117 fork
= &vhdr
->attr_file
;
118 tree
= sbi
->attr_tree
;
123 if (fork
->total_size
!= cpu_to_be64(inode
->i_size
)) {
124 set_bit(HFSPLUS_SB_WRITEBACKUP
, &sbi
->flags
);
125 inode
->i_sb
->s_dirt
= 1;
127 hfsplus_inode_write_fork(inode
, fork
);
129 hfs_btree_write(tree
);
133 static int hfsplus_write_inode(struct inode
*inode
,
134 struct writeback_control
*wbc
)
136 dprint(DBG_INODE
, "hfsplus_write_inode: %lu\n", inode
->i_ino
);
138 hfsplus_ext_write_extent(inode
);
140 if (inode
->i_ino
>= HFSPLUS_FIRSTUSER_CNID
||
141 inode
->i_ino
== HFSPLUS_ROOT_CNID
)
142 return hfsplus_cat_write_inode(inode
);
144 return hfsplus_system_write_inode(inode
);
147 static void hfsplus_evict_inode(struct inode
*inode
)
149 dprint(DBG_INODE
, "hfsplus_evict_inode: %lu\n", inode
->i_ino
);
150 truncate_inode_pages(&inode
->i_data
, 0);
151 end_writeback(inode
);
152 if (HFSPLUS_IS_RSRC(inode
)) {
153 HFSPLUS_I(HFSPLUS_I(inode
)->rsrc_inode
)->rsrc_inode
= NULL
;
154 iput(HFSPLUS_I(inode
)->rsrc_inode
);
158 int hfsplus_sync_fs(struct super_block
*sb
, int wait
)
160 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
161 struct hfsplus_vh
*vhdr
= sbi
->s_vhdr
;
162 int write_backup
= 0;
168 dprint(DBG_SUPER
, "hfsplus_write_super\n");
173 * Explicitly write out the special metadata inodes.
175 * While these special inodes are marked as hashed and written
176 * out peridocically by the flusher threads we redirty them
177 * during writeout of normal inodes, and thus the life lock
178 * prevents us from getting the latest state to disk.
180 error
= filemap_write_and_wait(sbi
->cat_tree
->inode
->i_mapping
);
181 error2
= filemap_write_and_wait(sbi
->ext_tree
->inode
->i_mapping
);
184 error2
= filemap_write_and_wait(sbi
->alloc_file
->i_mapping
);
188 mutex_lock(&sbi
->vh_mutex
);
189 mutex_lock(&sbi
->alloc_mutex
);
190 vhdr
->free_blocks
= cpu_to_be32(sbi
->free_blocks
);
191 vhdr
->next_cnid
= cpu_to_be32(sbi
->next_cnid
);
192 vhdr
->folder_count
= cpu_to_be32(sbi
->folder_count
);
193 vhdr
->file_count
= cpu_to_be32(sbi
->file_count
);
195 if (test_and_clear_bit(HFSPLUS_SB_WRITEBACKUP
, &sbi
->flags
)) {
196 memcpy(sbi
->s_backup_vhdr
, sbi
->s_vhdr
, sizeof(*sbi
->s_vhdr
));
200 error2
= hfsplus_submit_bio(sb
->s_bdev
,
201 sbi
->part_start
+ HFSPLUS_VOLHEAD_SECTOR
,
202 sbi
->s_vhdr
, WRITE_SYNC
);
208 error2
= hfsplus_submit_bio(sb
->s_bdev
,
209 sbi
->part_start
+ sbi
->sect_count
- 2,
210 sbi
->s_backup_vhdr
, WRITE_SYNC
);
214 mutex_unlock(&sbi
->alloc_mutex
);
215 mutex_unlock(&sbi
->vh_mutex
);
217 if (!test_bit(HFSPLUS_SB_NOBARRIER
, &sbi
->flags
))
218 blkdev_issue_flush(sb
->s_bdev
, GFP_KERNEL
, NULL
);
223 static void hfsplus_write_super(struct super_block
*sb
)
225 if (!(sb
->s_flags
& MS_RDONLY
))
226 hfsplus_sync_fs(sb
, 1);
231 static void hfsplus_put_super(struct super_block
*sb
)
233 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
235 dprint(DBG_SUPER
, "hfsplus_put_super\n");
240 if (!(sb
->s_flags
& MS_RDONLY
) && sbi
->s_vhdr
) {
241 struct hfsplus_vh
*vhdr
= sbi
->s_vhdr
;
243 vhdr
->modify_date
= hfsp_now2mt();
244 vhdr
->attributes
|= cpu_to_be32(HFSPLUS_VOL_UNMNT
);
245 vhdr
->attributes
&= cpu_to_be32(~HFSPLUS_VOL_INCNSTNT
);
247 hfsplus_sync_fs(sb
, 1);
250 hfs_btree_close(sbi
->cat_tree
);
251 hfs_btree_close(sbi
->ext_tree
);
252 iput(sbi
->alloc_file
);
253 iput(sbi
->hidden_dir
);
255 kfree(sbi
->s_backup_vhdr
);
256 unload_nls(sbi
->nls
);
257 kfree(sb
->s_fs_info
);
258 sb
->s_fs_info
= NULL
;
261 static int hfsplus_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
263 struct super_block
*sb
= dentry
->d_sb
;
264 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
265 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
267 buf
->f_type
= HFSPLUS_SUPER_MAGIC
;
268 buf
->f_bsize
= sb
->s_blocksize
;
269 buf
->f_blocks
= sbi
->total_blocks
<< sbi
->fs_shift
;
270 buf
->f_bfree
= sbi
->free_blocks
<< sbi
->fs_shift
;
271 buf
->f_bavail
= buf
->f_bfree
;
272 buf
->f_files
= 0xFFFFFFFF;
273 buf
->f_ffree
= 0xFFFFFFFF - sbi
->next_cnid
;
274 buf
->f_fsid
.val
[0] = (u32
)id
;
275 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
276 buf
->f_namelen
= HFSPLUS_MAX_STRLEN
;
281 static int hfsplus_remount(struct super_block
*sb
, int *flags
, char *data
)
283 if ((*flags
& MS_RDONLY
) == (sb
->s_flags
& MS_RDONLY
))
285 if (!(*flags
& MS_RDONLY
)) {
286 struct hfsplus_vh
*vhdr
= HFSPLUS_SB(sb
)->s_vhdr
;
289 if (!hfsplus_parse_options_remount(data
, &force
))
292 if (!(vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_UNMNT
))) {
293 printk(KERN_WARNING
"hfs: filesystem was not cleanly unmounted, "
294 "running fsck.hfsplus is recommended. leaving read-only.\n");
295 sb
->s_flags
|= MS_RDONLY
;
299 } else if (vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_SOFTLOCK
)) {
300 printk(KERN_WARNING
"hfs: filesystem is marked locked, leaving read-only.\n");
301 sb
->s_flags
|= MS_RDONLY
;
303 } else if (vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_JOURNALED
)) {
304 printk(KERN_WARNING
"hfs: filesystem is marked journaled, leaving read-only.\n");
305 sb
->s_flags
|= MS_RDONLY
;
312 static const struct super_operations hfsplus_sops
= {
313 .alloc_inode
= hfsplus_alloc_inode
,
314 .destroy_inode
= hfsplus_destroy_inode
,
315 .write_inode
= hfsplus_write_inode
,
316 .evict_inode
= hfsplus_evict_inode
,
317 .put_super
= hfsplus_put_super
,
318 .write_super
= hfsplus_write_super
,
319 .sync_fs
= hfsplus_sync_fs
,
320 .statfs
= hfsplus_statfs
,
321 .remount_fs
= hfsplus_remount
,
322 .show_options
= hfsplus_show_options
,
325 static int hfsplus_fill_super(struct super_block
*sb
, void *data
, int silent
)
327 struct hfsplus_vh
*vhdr
;
328 struct hfsplus_sb_info
*sbi
;
329 hfsplus_cat_entry entry
;
330 struct hfs_find_data fd
;
331 struct inode
*root
, *inode
;
333 struct nls_table
*nls
= NULL
;
336 sbi
= kzalloc(sizeof(*sbi
), GFP_KERNEL
);
341 mutex_init(&sbi
->alloc_mutex
);
342 mutex_init(&sbi
->vh_mutex
);
343 hfsplus_fill_defaults(sbi
);
344 if (!hfsplus_parse_options(data
, sbi
)) {
345 printk(KERN_ERR
"hfs: unable to parse mount options\n");
350 /* temporarily use utf8 to correctly find the hidden dir below */
352 sbi
->nls
= load_nls("utf8");
354 printk(KERN_ERR
"hfs: unable to load nls for utf8\n");
359 /* Grab the volume header */
360 if (hfsplus_read_wrapper(sb
)) {
362 printk(KERN_WARNING
"hfs: unable to find HFS+ superblock\n");
368 /* Copy parts of the volume header into the superblock */
369 sb
->s_magic
= HFSPLUS_VOLHEAD_SIG
;
370 if (be16_to_cpu(vhdr
->version
) < HFSPLUS_MIN_VERSION
||
371 be16_to_cpu(vhdr
->version
) > HFSPLUS_CURRENT_VERSION
) {
372 printk(KERN_ERR
"hfs: wrong filesystem version\n");
375 sbi
->total_blocks
= be32_to_cpu(vhdr
->total_blocks
);
376 sbi
->free_blocks
= be32_to_cpu(vhdr
->free_blocks
);
377 sbi
->next_cnid
= be32_to_cpu(vhdr
->next_cnid
);
378 sbi
->file_count
= be32_to_cpu(vhdr
->file_count
);
379 sbi
->folder_count
= be32_to_cpu(vhdr
->folder_count
);
380 sbi
->data_clump_blocks
=
381 be32_to_cpu(vhdr
->data_clump_sz
) >> sbi
->alloc_blksz_shift
;
382 if (!sbi
->data_clump_blocks
)
383 sbi
->data_clump_blocks
= 1;
384 sbi
->rsrc_clump_blocks
=
385 be32_to_cpu(vhdr
->rsrc_clump_sz
) >> sbi
->alloc_blksz_shift
;
386 if (!sbi
->rsrc_clump_blocks
)
387 sbi
->rsrc_clump_blocks
= 1;
389 /* Set up operations so we can load metadata */
390 sb
->s_op
= &hfsplus_sops
;
391 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
393 if (!(vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_UNMNT
))) {
394 printk(KERN_WARNING
"hfs: Filesystem was not cleanly unmounted, "
395 "running fsck.hfsplus is recommended. mounting read-only.\n");
396 sb
->s_flags
|= MS_RDONLY
;
397 } else if (test_and_clear_bit(HFSPLUS_SB_FORCE
, &sbi
->flags
)) {
399 } else if (vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_SOFTLOCK
)) {
400 printk(KERN_WARNING
"hfs: Filesystem is marked locked, mounting read-only.\n");
401 sb
->s_flags
|= MS_RDONLY
;
402 } else if ((vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_JOURNALED
)) && !(sb
->s_flags
& MS_RDONLY
)) {
403 printk(KERN_WARNING
"hfs: write access to a journaled filesystem is not supported, "
404 "use the force option at your own risk, mounting read-only.\n");
405 sb
->s_flags
|= MS_RDONLY
;
408 /* Load metadata objects (B*Trees) */
409 sbi
->ext_tree
= hfs_btree_open(sb
, HFSPLUS_EXT_CNID
);
410 if (!sbi
->ext_tree
) {
411 printk(KERN_ERR
"hfs: failed to load extents file\n");
414 sbi
->cat_tree
= hfs_btree_open(sb
, HFSPLUS_CAT_CNID
);
415 if (!sbi
->cat_tree
) {
416 printk(KERN_ERR
"hfs: failed to load catalog file\n");
420 inode
= hfsplus_iget(sb
, HFSPLUS_ALLOC_CNID
);
422 printk(KERN_ERR
"hfs: failed to load allocation file\n");
423 err
= PTR_ERR(inode
);
426 sbi
->alloc_file
= inode
;
428 /* Load the root directory */
429 root
= hfsplus_iget(sb
, HFSPLUS_ROOT_CNID
);
431 printk(KERN_ERR
"hfs: failed to load root directory\n");
435 sb
->s_root
= d_alloc_root(root
);
441 sb
->s_root
->d_op
= &hfsplus_dentry_operations
;
443 str
.len
= sizeof(HFSP_HIDDENDIR_NAME
) - 1;
444 str
.name
= HFSP_HIDDENDIR_NAME
;
445 hfs_find_init(sbi
->cat_tree
, &fd
);
446 hfsplus_cat_build_key(sb
, fd
.search_key
, HFSPLUS_ROOT_CNID
, &str
);
447 if (!hfs_brec_read(&fd
, &entry
, sizeof(entry
))) {
449 if (entry
.type
!= cpu_to_be16(HFSPLUS_FOLDER
))
451 inode
= hfsplus_iget(sb
, be32_to_cpu(entry
.folder
.id
));
453 err
= PTR_ERR(inode
);
456 sbi
->hidden_dir
= inode
;
460 if (sb
->s_flags
& MS_RDONLY
)
463 /* H+LX == hfsplusutils, H+Lx == this driver, H+lx is unused
464 * all three are registered with Apple for our use
466 vhdr
->last_mount_vers
= cpu_to_be32(HFSP_MOUNT_VERSION
);
467 vhdr
->modify_date
= hfsp_now2mt();
468 be32_add_cpu(&vhdr
->write_count
, 1);
469 vhdr
->attributes
&= cpu_to_be32(~HFSPLUS_VOL_UNMNT
);
470 vhdr
->attributes
|= cpu_to_be32(HFSPLUS_VOL_INCNSTNT
);
471 hfsplus_sync_fs(sb
, 1);
473 if (!sbi
->hidden_dir
) {
474 mutex_lock(&sbi
->vh_mutex
);
475 sbi
->hidden_dir
= hfsplus_new_inode(sb
, S_IFDIR
);
476 hfsplus_create_cat(sbi
->hidden_dir
->i_ino
, sb
->s_root
->d_inode
,
477 &str
, sbi
->hidden_dir
);
478 mutex_unlock(&sbi
->vh_mutex
);
480 hfsplus_mark_inode_dirty(sbi
->hidden_dir
, HFSPLUS_I_CAT_DIRTY
);
483 unload_nls(sbi
->nls
);
488 hfsplus_put_super(sb
);
493 MODULE_AUTHOR("Brad Boyer");
494 MODULE_DESCRIPTION("Extended Macintosh Filesystem");
495 MODULE_LICENSE("GPL");
497 static struct kmem_cache
*hfsplus_inode_cachep
;
499 static struct inode
*hfsplus_alloc_inode(struct super_block
*sb
)
501 struct hfsplus_inode_info
*i
;
503 i
= kmem_cache_alloc(hfsplus_inode_cachep
, GFP_KERNEL
);
504 return i
? &i
->vfs_inode
: NULL
;
507 static void hfsplus_destroy_inode(struct inode
*inode
)
509 kmem_cache_free(hfsplus_inode_cachep
, HFSPLUS_I(inode
));
512 #define HFSPLUS_INODE_SIZE sizeof(struct hfsplus_inode_info)
514 static struct dentry
*hfsplus_mount(struct file_system_type
*fs_type
,
515 int flags
, const char *dev_name
, void *data
)
517 return mount_bdev(fs_type
, flags
, dev_name
, data
, hfsplus_fill_super
);
520 static struct file_system_type hfsplus_fs_type
= {
521 .owner
= THIS_MODULE
,
523 .mount
= hfsplus_mount
,
524 .kill_sb
= kill_block_super
,
525 .fs_flags
= FS_REQUIRES_DEV
,
528 static void hfsplus_init_once(void *p
)
530 struct hfsplus_inode_info
*i
= p
;
532 inode_init_once(&i
->vfs_inode
);
535 static int __init
init_hfsplus_fs(void)
539 hfsplus_inode_cachep
= kmem_cache_create("hfsplus_icache",
540 HFSPLUS_INODE_SIZE
, 0, SLAB_HWCACHE_ALIGN
,
542 if (!hfsplus_inode_cachep
)
544 err
= register_filesystem(&hfsplus_fs_type
);
546 kmem_cache_destroy(hfsplus_inode_cachep
);
550 static void __exit
exit_hfsplus_fs(void)
552 unregister_filesystem(&hfsplus_fs_type
);
553 kmem_cache_destroy(hfsplus_inode_cachep
);
556 module_init(init_hfsplus_fs
)
557 module_exit(exit_hfsplus_fs
)