2 * linux/fs/hfsplus/super.c
5 * Brad Boyer (flar@allandria.com)
6 * (C) 2003 Ardis Technologies <roman@ardistech.com>
10 #include <linux/config.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/pagemap.h>
15 #include <linux/sched.h>
16 #include <linux/slab.h>
17 #include <linux/vfs.h>
18 #include <linux/nls.h>
20 static struct inode
*hfsplus_alloc_inode(struct super_block
*sb
);
21 static void hfsplus_destroy_inode(struct inode
*inode
);
23 #include "hfsplus_fs.h"
25 static void hfsplus_read_inode(struct inode
*inode
)
27 struct hfs_find_data fd
;
28 struct hfsplus_vh
*vhdr
;
31 INIT_LIST_HEAD(&HFSPLUS_I(inode
).open_dir_list
);
32 init_MUTEX(&HFSPLUS_I(inode
).extents_lock
);
33 HFSPLUS_I(inode
).flags
= 0;
34 HFSPLUS_I(inode
).rsrc_inode
= NULL
;
35 atomic_set(&HFSPLUS_I(inode
).opencnt
, 0);
37 if (inode
->i_ino
>= HFSPLUS_FIRSTUSER_CNID
) {
39 hfs_find_init(HFSPLUS_SB(inode
->i_sb
).cat_tree
, &fd
);
40 err
= hfsplus_find_cat(inode
->i_sb
, inode
->i_ino
, &fd
);
42 err
= hfsplus_cat_read_inode(inode
, &fd
);
48 vhdr
= HFSPLUS_SB(inode
->i_sb
).s_vhdr
;
49 switch(inode
->i_ino
) {
50 case HFSPLUS_ROOT_CNID
:
52 case HFSPLUS_EXT_CNID
:
53 hfsplus_inode_read_fork(inode
, &vhdr
->ext_file
);
54 inode
->i_mapping
->a_ops
= &hfsplus_btree_aops
;
56 case HFSPLUS_CAT_CNID
:
57 hfsplus_inode_read_fork(inode
, &vhdr
->cat_file
);
58 inode
->i_mapping
->a_ops
= &hfsplus_btree_aops
;
60 case HFSPLUS_ALLOC_CNID
:
61 hfsplus_inode_read_fork(inode
, &vhdr
->alloc_file
);
62 inode
->i_mapping
->a_ops
= &hfsplus_aops
;
64 case HFSPLUS_START_CNID
:
65 hfsplus_inode_read_fork(inode
, &vhdr
->start_file
);
67 case HFSPLUS_ATTR_CNID
:
68 hfsplus_inode_read_fork(inode
, &vhdr
->attr_file
);
69 inode
->i_mapping
->a_ops
= &hfsplus_btree_aops
;
78 make_bad_inode(inode
);
81 static int hfsplus_write_inode(struct inode
*inode
, int unused
)
83 struct hfsplus_vh
*vhdr
;
86 dprint(DBG_INODE
, "hfsplus_write_inode: %lu\n", inode
->i_ino
);
87 hfsplus_ext_write_extent(inode
);
88 if (inode
->i_ino
>= HFSPLUS_FIRSTUSER_CNID
) {
89 return hfsplus_cat_write_inode(inode
);
91 vhdr
= HFSPLUS_SB(inode
->i_sb
).s_vhdr
;
92 switch (inode
->i_ino
) {
93 case HFSPLUS_ROOT_CNID
:
94 ret
= hfsplus_cat_write_inode(inode
);
96 case HFSPLUS_EXT_CNID
:
97 if (vhdr
->ext_file
.total_size
!= cpu_to_be64(inode
->i_size
)) {
98 HFSPLUS_SB(inode
->i_sb
).flags
|= HFSPLUS_SB_WRITEBACKUP
;
99 inode
->i_sb
->s_dirt
= 1;
101 hfsplus_inode_write_fork(inode
, &vhdr
->ext_file
);
102 hfs_btree_write(HFSPLUS_SB(inode
->i_sb
).ext_tree
);
104 case HFSPLUS_CAT_CNID
:
105 if (vhdr
->cat_file
.total_size
!= cpu_to_be64(inode
->i_size
)) {
106 HFSPLUS_SB(inode
->i_sb
).flags
|= HFSPLUS_SB_WRITEBACKUP
;
107 inode
->i_sb
->s_dirt
= 1;
109 hfsplus_inode_write_fork(inode
, &vhdr
->cat_file
);
110 hfs_btree_write(HFSPLUS_SB(inode
->i_sb
).cat_tree
);
112 case HFSPLUS_ALLOC_CNID
:
113 if (vhdr
->alloc_file
.total_size
!= cpu_to_be64(inode
->i_size
)) {
114 HFSPLUS_SB(inode
->i_sb
).flags
|= HFSPLUS_SB_WRITEBACKUP
;
115 inode
->i_sb
->s_dirt
= 1;
117 hfsplus_inode_write_fork(inode
, &vhdr
->alloc_file
);
119 case HFSPLUS_START_CNID
:
120 if (vhdr
->start_file
.total_size
!= cpu_to_be64(inode
->i_size
)) {
121 HFSPLUS_SB(inode
->i_sb
).flags
|= HFSPLUS_SB_WRITEBACKUP
;
122 inode
->i_sb
->s_dirt
= 1;
124 hfsplus_inode_write_fork(inode
, &vhdr
->start_file
);
126 case HFSPLUS_ATTR_CNID
:
127 if (vhdr
->attr_file
.total_size
!= cpu_to_be64(inode
->i_size
)) {
128 HFSPLUS_SB(inode
->i_sb
).flags
|= HFSPLUS_SB_WRITEBACKUP
;
129 inode
->i_sb
->s_dirt
= 1;
131 hfsplus_inode_write_fork(inode
, &vhdr
->attr_file
);
132 hfs_btree_write(HFSPLUS_SB(inode
->i_sb
).attr_tree
);
138 static void hfsplus_clear_inode(struct inode
*inode
)
140 dprint(DBG_INODE
, "hfsplus_clear_inode: %lu\n", inode
->i_ino
);
141 if (HFSPLUS_IS_RSRC(inode
)) {
142 HFSPLUS_I(HFSPLUS_I(inode
).rsrc_inode
).rsrc_inode
= NULL
;
143 iput(HFSPLUS_I(inode
).rsrc_inode
);
147 static void hfsplus_write_super(struct super_block
*sb
)
149 struct hfsplus_vh
*vhdr
= HFSPLUS_SB(sb
).s_vhdr
;
151 dprint(DBG_SUPER
, "hfsplus_write_super\n");
153 if (sb
->s_flags
& MS_RDONLY
)
157 vhdr
->free_blocks
= cpu_to_be32(HFSPLUS_SB(sb
).free_blocks
);
158 vhdr
->next_alloc
= cpu_to_be32(HFSPLUS_SB(sb
).next_alloc
);
159 vhdr
->next_cnid
= cpu_to_be32(HFSPLUS_SB(sb
).next_cnid
);
160 vhdr
->folder_count
= cpu_to_be32(HFSPLUS_SB(sb
).folder_count
);
161 vhdr
->file_count
= cpu_to_be32(HFSPLUS_SB(sb
).file_count
);
163 mark_buffer_dirty(HFSPLUS_SB(sb
).s_vhbh
);
164 if (HFSPLUS_SB(sb
).flags
& HFSPLUS_SB_WRITEBACKUP
) {
165 if (HFSPLUS_SB(sb
).sect_count
) {
166 struct buffer_head
*bh
;
169 block
= HFSPLUS_SB(sb
).blockoffset
;
170 block
+= (HFSPLUS_SB(sb
).sect_count
- 2) >> (sb
->s_blocksize_bits
- 9);
171 offset
= ((HFSPLUS_SB(sb
).sect_count
- 2) << 9) & (sb
->s_blocksize
- 1);
172 printk("backup: %u,%u,%u,%u\n", HFSPLUS_SB(sb
).blockoffset
,
173 HFSPLUS_SB(sb
).sect_count
, block
, offset
);
174 bh
= sb_bread(sb
, block
);
176 vhdr
= (struct hfsplus_vh
*)(bh
->b_data
+ offset
);
177 if (be16_to_cpu(vhdr
->signature
) == HFSPLUS_VOLHEAD_SIG
) {
178 memcpy(vhdr
, HFSPLUS_SB(sb
).s_vhdr
, sizeof(*vhdr
));
179 mark_buffer_dirty(bh
);
182 printk("backup not found!\n");
185 HFSPLUS_SB(sb
).flags
&= ~HFSPLUS_SB_WRITEBACKUP
;
189 static void hfsplus_put_super(struct super_block
*sb
)
191 dprint(DBG_SUPER
, "hfsplus_put_super\n");
194 if (!(sb
->s_flags
& MS_RDONLY
) && HFSPLUS_SB(sb
).s_vhdr
) {
195 struct hfsplus_vh
*vhdr
= HFSPLUS_SB(sb
).s_vhdr
;
197 vhdr
->modify_date
= hfsp_now2mt();
198 vhdr
->attributes
|= cpu_to_be32(HFSPLUS_VOL_UNMNT
);
199 vhdr
->attributes
&= cpu_to_be32(~HFSPLUS_VOL_INCNSTNT
);
200 mark_buffer_dirty(HFSPLUS_SB(sb
).s_vhbh
);
201 sync_dirty_buffer(HFSPLUS_SB(sb
).s_vhbh
);
204 hfs_btree_close(HFSPLUS_SB(sb
).cat_tree
);
205 hfs_btree_close(HFSPLUS_SB(sb
).ext_tree
);
206 iput(HFSPLUS_SB(sb
).alloc_file
);
207 iput(HFSPLUS_SB(sb
).hidden_dir
);
208 brelse(HFSPLUS_SB(sb
).s_vhbh
);
209 if (HFSPLUS_SB(sb
).nls
)
210 unload_nls(HFSPLUS_SB(sb
).nls
);
211 kfree(sb
->s_fs_info
);
212 sb
->s_fs_info
= NULL
;
215 static int hfsplus_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
217 buf
->f_type
= HFSPLUS_SUPER_MAGIC
;
218 buf
->f_bsize
= sb
->s_blocksize
;
219 buf
->f_blocks
= HFSPLUS_SB(sb
).total_blocks
<< HFSPLUS_SB(sb
).fs_shift
;
220 buf
->f_bfree
= HFSPLUS_SB(sb
).free_blocks
<< HFSPLUS_SB(sb
).fs_shift
;
221 buf
->f_bavail
= buf
->f_bfree
;
222 buf
->f_files
= 0xFFFFFFFF;
223 buf
->f_ffree
= 0xFFFFFFFF - HFSPLUS_SB(sb
).next_cnid
;
224 buf
->f_namelen
= HFSPLUS_MAX_STRLEN
;
229 static int hfsplus_remount(struct super_block
*sb
, int *flags
, char *data
)
231 if ((*flags
& MS_RDONLY
) == (sb
->s_flags
& MS_RDONLY
))
233 if (!(*flags
& MS_RDONLY
)) {
234 struct hfsplus_vh
*vhdr
= HFSPLUS_SB(sb
).s_vhdr
;
235 struct hfsplus_sb_info sbi
;
237 memset(&sbi
, 0, sizeof(struct hfsplus_sb_info
));
238 sbi
.nls
= HFSPLUS_SB(sb
).nls
;
239 if (!hfsplus_parse_options(data
, &sbi
))
242 if (!(vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_UNMNT
))) {
243 printk("HFS+-fs warning: Filesystem was not cleanly unmounted, "
244 "running fsck.hfsplus is recommended. leaving read-only.\n");
245 sb
->s_flags
|= MS_RDONLY
;
247 } else if (sbi
.flags
& HFSPLUS_SB_FORCE
) {
249 } else if (vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_SOFTLOCK
)) {
250 printk("HFS+-fs: Filesystem is marked locked, leaving read-only.\n");
251 sb
->s_flags
|= MS_RDONLY
;
253 } else if (vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_JOURNALED
)) {
254 printk("HFS+-fs: Filesystem is marked journaled, leaving read-only.\n");
255 sb
->s_flags
|= MS_RDONLY
;
262 static struct super_operations hfsplus_sops
= {
263 .alloc_inode
= hfsplus_alloc_inode
,
264 .destroy_inode
= hfsplus_destroy_inode
,
265 .read_inode
= hfsplus_read_inode
,
266 .write_inode
= hfsplus_write_inode
,
267 .clear_inode
= hfsplus_clear_inode
,
268 .put_super
= hfsplus_put_super
,
269 .write_super
= hfsplus_write_super
,
270 .statfs
= hfsplus_statfs
,
271 .remount_fs
= hfsplus_remount
,
272 .show_options
= hfsplus_show_options
,
275 static int hfsplus_fill_super(struct super_block
*sb
, void *data
, int silent
)
277 struct hfsplus_vh
*vhdr
;
278 struct hfsplus_sb_info
*sbi
;
279 hfsplus_cat_entry entry
;
280 struct hfs_find_data fd
;
283 struct nls_table
*nls
= NULL
;
286 sbi
= kmalloc(sizeof(struct hfsplus_sb_info
), GFP_KERNEL
);
290 memset(sbi
, 0, sizeof(HFSPLUS_SB(sb
)));
292 INIT_HLIST_HEAD(&sbi
->rsrc_inodes
);
293 hfsplus_fill_defaults(sbi
);
294 if (!hfsplus_parse_options(data
, sbi
)) {
296 printk("HFS+-fs: unable to parse mount options\n");
301 /* temporarily use utf8 to correctly find the hidden dir below */
303 sbi
->nls
= load_nls("utf8");
305 printk("HFS+: unable to load nls for utf8\n");
310 /* Grab the volume header */
311 if (hfsplus_read_wrapper(sb
)) {
313 printk("HFS+-fs: unable to find HFS+ superblock\n");
317 vhdr
= HFSPLUS_SB(sb
).s_vhdr
;
319 /* Copy parts of the volume header into the superblock */
320 sb
->s_magic
= be16_to_cpu(vhdr
->signature
);
321 if (be16_to_cpu(vhdr
->version
) != HFSPLUS_CURRENT_VERSION
) {
323 printk("HFS+-fs: wrong filesystem version\n");
326 HFSPLUS_SB(sb
).total_blocks
= be32_to_cpu(vhdr
->total_blocks
);
327 HFSPLUS_SB(sb
).free_blocks
= be32_to_cpu(vhdr
->free_blocks
);
328 HFSPLUS_SB(sb
).next_alloc
= be32_to_cpu(vhdr
->next_alloc
);
329 HFSPLUS_SB(sb
).next_cnid
= be32_to_cpu(vhdr
->next_cnid
);
330 HFSPLUS_SB(sb
).file_count
= be32_to_cpu(vhdr
->file_count
);
331 HFSPLUS_SB(sb
).folder_count
= be32_to_cpu(vhdr
->folder_count
);
332 HFSPLUS_SB(sb
).data_clump_blocks
= be32_to_cpu(vhdr
->data_clump_sz
) >> HFSPLUS_SB(sb
).alloc_blksz_shift
;
333 if (!HFSPLUS_SB(sb
).data_clump_blocks
)
334 HFSPLUS_SB(sb
).data_clump_blocks
= 1;
335 HFSPLUS_SB(sb
).rsrc_clump_blocks
= be32_to_cpu(vhdr
->rsrc_clump_sz
) >> HFSPLUS_SB(sb
).alloc_blksz_shift
;
336 if (!HFSPLUS_SB(sb
).rsrc_clump_blocks
)
337 HFSPLUS_SB(sb
).rsrc_clump_blocks
= 1;
339 /* Set up operations so we can load metadata */
340 sb
->s_op
= &hfsplus_sops
;
341 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
343 if (!(vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_UNMNT
))) {
345 printk("HFS+-fs warning: Filesystem was not cleanly unmounted, "
346 "running fsck.hfsplus is recommended. mounting read-only.\n");
347 sb
->s_flags
|= MS_RDONLY
;
348 } else if (sbi
->flags
& HFSPLUS_SB_FORCE
) {
350 } else if (vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_SOFTLOCK
)) {
352 printk("HFS+-fs: Filesystem is marked locked, mounting read-only.\n");
353 sb
->s_flags
|= MS_RDONLY
;
354 } else if (vhdr
->attributes
& cpu_to_be32(HFSPLUS_VOL_JOURNALED
)) {
356 printk("HFS+-fs: write access to a jounaled filesystem is not supported, "
357 "use the force option at your own risk, mounting read-only.\n");
358 sb
->s_flags
|= MS_RDONLY
;
360 sbi
->flags
&= ~HFSPLUS_SB_FORCE
;
362 /* Load metadata objects (B*Trees) */
363 HFSPLUS_SB(sb
).ext_tree
= hfs_btree_open(sb
, HFSPLUS_EXT_CNID
);
364 if (!HFSPLUS_SB(sb
).ext_tree
) {
366 printk("HFS+-fs: failed to load extents file\n");
369 HFSPLUS_SB(sb
).cat_tree
= hfs_btree_open(sb
, HFSPLUS_CAT_CNID
);
370 if (!HFSPLUS_SB(sb
).cat_tree
) {
372 printk("HFS+-fs: failed to load catalog file\n");
376 HFSPLUS_SB(sb
).alloc_file
= iget(sb
, HFSPLUS_ALLOC_CNID
);
377 if (!HFSPLUS_SB(sb
).alloc_file
) {
379 printk("HFS+-fs: failed to load allocation file\n");
383 /* Load the root directory */
384 root
= iget(sb
, HFSPLUS_ROOT_CNID
);
385 sb
->s_root
= d_alloc_root(root
);
388 printk("HFS+-fs: failed to load root directory\n");
393 str
.len
= sizeof(HFSP_HIDDENDIR_NAME
) - 1;
394 str
.name
= HFSP_HIDDENDIR_NAME
;
395 hfs_find_init(HFSPLUS_SB(sb
).cat_tree
, &fd
);
396 hfsplus_cat_build_key(sb
, fd
.search_key
, HFSPLUS_ROOT_CNID
, &str
);
397 if (!hfs_brec_read(&fd
, &entry
, sizeof(entry
))) {
399 if (entry
.type
!= cpu_to_be16(HFSPLUS_FOLDER
))
401 HFSPLUS_SB(sb
).hidden_dir
= iget(sb
, be32_to_cpu(entry
.folder
.id
));
402 if (!HFSPLUS_SB(sb
).hidden_dir
)
407 if (sb
->s_flags
& MS_RDONLY
)
410 /* H+LX == hfsplusutils, H+Lx == this driver, H+lx is unused
411 * all three are registered with Apple for our use
413 vhdr
->last_mount_vers
= cpu_to_be32(HFSP_MOUNT_VERSION
);
414 vhdr
->modify_date
= hfsp_now2mt();
415 vhdr
->write_count
= cpu_to_be32(be32_to_cpu(vhdr
->write_count
) + 1);
416 vhdr
->attributes
&= cpu_to_be32(~HFSPLUS_VOL_UNMNT
);
417 vhdr
->attributes
|= cpu_to_be32(HFSPLUS_VOL_INCNSTNT
);
418 mark_buffer_dirty(HFSPLUS_SB(sb
).s_vhbh
);
419 sync_dirty_buffer(HFSPLUS_SB(sb
).s_vhbh
);
421 if (!HFSPLUS_SB(sb
).hidden_dir
) {
422 printk("HFS+: create hidden dir...\n");
423 HFSPLUS_SB(sb
).hidden_dir
= hfsplus_new_inode(sb
, S_IFDIR
);
424 hfsplus_create_cat(HFSPLUS_SB(sb
).hidden_dir
->i_ino
, sb
->s_root
->d_inode
,
425 &str
, HFSPLUS_SB(sb
).hidden_dir
);
426 mark_inode_dirty(HFSPLUS_SB(sb
).hidden_dir
);
429 unload_nls(sbi
->nls
);
434 hfsplus_put_super(sb
);
440 MODULE_AUTHOR("Brad Boyer");
441 MODULE_DESCRIPTION("Extended Macintosh Filesystem");
442 MODULE_LICENSE("GPL");
444 static kmem_cache_t
*hfsplus_inode_cachep
;
446 static struct inode
*hfsplus_alloc_inode(struct super_block
*sb
)
448 struct hfsplus_inode_info
*i
;
450 i
= kmem_cache_alloc(hfsplus_inode_cachep
, SLAB_KERNEL
);
451 return i
? &i
->vfs_inode
: NULL
;
454 static void hfsplus_destroy_inode(struct inode
*inode
)
456 kmem_cache_free(hfsplus_inode_cachep
, &HFSPLUS_I(inode
));
459 #define HFSPLUS_INODE_SIZE sizeof(struct hfsplus_inode_info)
461 static struct super_block
*hfsplus_get_sb(struct file_system_type
*fs_type
,
462 int flags
, const char *dev_name
, void *data
)
464 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, hfsplus_fill_super
);
467 static struct file_system_type hfsplus_fs_type
= {
468 .owner
= THIS_MODULE
,
470 .get_sb
= hfsplus_get_sb
,
471 .kill_sb
= kill_block_super
,
472 .fs_flags
= FS_REQUIRES_DEV
,
475 static void hfsplus_init_once(void *p
, kmem_cache_t
*cachep
, unsigned long flags
)
477 struct hfsplus_inode_info
*i
= p
;
479 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) == SLAB_CTOR_CONSTRUCTOR
)
480 inode_init_once(&i
->vfs_inode
);
483 static int __init
init_hfsplus_fs(void)
487 hfsplus_inode_cachep
= kmem_cache_create("hfsplus_icache",
488 HFSPLUS_INODE_SIZE
, 0, SLAB_HWCACHE_ALIGN
,
489 hfsplus_init_once
, NULL
);
490 if (!hfsplus_inode_cachep
)
492 err
= register_filesystem(&hfsplus_fs_type
);
494 kmem_cache_destroy(hfsplus_inode_cachep
);
498 static void __exit
exit_hfsplus_fs(void)
500 unregister_filesystem(&hfsplus_fs_type
);
501 if (kmem_cache_destroy(hfsplus_inode_cachep
))
502 printk(KERN_INFO
"hfsplus_inode_cache: not all structures were freed\n");
505 module_init(init_hfsplus_fs
)
506 module_exit(exit_hfsplus_fs
)