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.
8 * This file contains hfs_read_super(), some of the super_ops and
9 * init_hfs_fs() and exit_hfs_fs(). The remaining super_ops are in
10 * inode.c since they deal with inodes.
12 * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
15 #include <linux/module.h>
16 #include <linux/blkdev.h>
17 #include <linux/mount.h>
18 #include <linux/init.h>
19 #include <linux/nls.h>
20 #include <linux/parser.h>
21 #include <linux/seq_file.h>
22 #include <linux/slab.h>
23 #include <linux/vfs.h>
28 static struct kmem_cache
*hfs_inode_cachep
;
30 MODULE_LICENSE("GPL");
36 * This function is called by the VFS only. When the filesystem
37 * is mounted r/w it updates the MDB on disk.
39 * struct super_block *sb: Pointer to the hfs superblock
45 * 'sb' points to a "valid" (struct super_block).
47 * The MDB is marked 'unsuccessfully unmounted' by clearing bit 8 of drAtrb
48 * (hfs_put_super() must set this flag!). Some MDB fields are updated
49 * and the MDB buffer is written to disk by calling hfs_mdb_commit().
51 static void hfs_write_super(struct super_block
*sb
)
55 /* sync everything to the buffers */
59 static int hfs_sync_fs(struct super_block
*sb
, int wait
)
70 * This is the put_super() entry in the super_operations structure for
71 * HFS filesystems. The purpose is to release the resources
72 * associated with the superblock sb.
74 static void hfs_put_super(struct super_block
*sb
)
77 /* release the MDB's resources */
84 * This is the statfs() entry in the super_operations structure for
85 * HFS filesystems. The purpose is to return various data about the
88 * changed f_files/f_ffree to reflect the fs_ablock/free_ablocks.
90 static int hfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
92 struct super_block
*sb
= dentry
->d_sb
;
93 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
95 buf
->f_type
= HFS_SUPER_MAGIC
;
96 buf
->f_bsize
= sb
->s_blocksize
;
97 buf
->f_blocks
= (u32
)HFS_SB(sb
)->fs_ablocks
* HFS_SB(sb
)->fs_div
;
98 buf
->f_bfree
= (u32
)HFS_SB(sb
)->free_ablocks
* HFS_SB(sb
)->fs_div
;
99 buf
->f_bavail
= buf
->f_bfree
;
100 buf
->f_files
= HFS_SB(sb
)->fs_ablocks
;
101 buf
->f_ffree
= HFS_SB(sb
)->free_ablocks
;
102 buf
->f_fsid
.val
[0] = (u32
)id
;
103 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
104 buf
->f_namelen
= HFS_NAMELEN
;
109 static int hfs_remount(struct super_block
*sb
, int *flags
, char *data
)
111 *flags
|= MS_NODIRATIME
;
112 if ((*flags
& MS_RDONLY
) == (sb
->s_flags
& MS_RDONLY
))
114 if (!(*flags
& MS_RDONLY
)) {
115 if (!(HFS_SB(sb
)->mdb
->drAtrb
& cpu_to_be16(HFS_SB_ATTRIB_UNMNT
))) {
116 printk(KERN_WARNING
"hfs: filesystem was not cleanly unmounted, "
117 "running fsck.hfs is recommended. leaving read-only.\n");
118 sb
->s_flags
|= MS_RDONLY
;
120 } else if (HFS_SB(sb
)->mdb
->drAtrb
& cpu_to_be16(HFS_SB_ATTRIB_SLOCK
)) {
121 printk(KERN_WARNING
"hfs: filesystem is marked locked, leaving read-only.\n");
122 sb
->s_flags
|= MS_RDONLY
;
129 static int hfs_show_options(struct seq_file
*seq
, struct dentry
*root
)
131 struct hfs_sb_info
*sbi
= HFS_SB(root
->d_sb
);
133 if (sbi
->s_creator
!= cpu_to_be32(0x3f3f3f3f))
134 seq_printf(seq
, ",creator=%.4s", (char *)&sbi
->s_creator
);
135 if (sbi
->s_type
!= cpu_to_be32(0x3f3f3f3f))
136 seq_printf(seq
, ",type=%.4s", (char *)&sbi
->s_type
);
137 seq_printf(seq
, ",uid=%u,gid=%u", sbi
->s_uid
, sbi
->s_gid
);
138 if (sbi
->s_file_umask
!= 0133)
139 seq_printf(seq
, ",file_umask=%o", sbi
->s_file_umask
);
140 if (sbi
->s_dir_umask
!= 0022)
141 seq_printf(seq
, ",dir_umask=%o", sbi
->s_dir_umask
);
143 seq_printf(seq
, ",part=%u", sbi
->part
);
144 if (sbi
->session
>= 0)
145 seq_printf(seq
, ",session=%u", sbi
->session
);
147 seq_printf(seq
, ",codepage=%s", sbi
->nls_disk
->charset
);
149 seq_printf(seq
, ",iocharset=%s", sbi
->nls_io
->charset
);
151 seq_printf(seq
, ",quiet");
155 static struct inode
*hfs_alloc_inode(struct super_block
*sb
)
157 struct hfs_inode_info
*i
;
159 i
= kmem_cache_alloc(hfs_inode_cachep
, GFP_KERNEL
);
160 return i
? &i
->vfs_inode
: NULL
;
163 static void hfs_i_callback(struct rcu_head
*head
)
165 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
166 kmem_cache_free(hfs_inode_cachep
, HFS_I(inode
));
169 static void hfs_destroy_inode(struct inode
*inode
)
171 call_rcu(&inode
->i_rcu
, hfs_i_callback
);
174 static const struct super_operations hfs_super_operations
= {
175 .alloc_inode
= hfs_alloc_inode
,
176 .destroy_inode
= hfs_destroy_inode
,
177 .write_inode
= hfs_write_inode
,
178 .evict_inode
= hfs_evict_inode
,
179 .put_super
= hfs_put_super
,
180 .write_super
= hfs_write_super
,
181 .sync_fs
= hfs_sync_fs
,
182 .statfs
= hfs_statfs
,
183 .remount_fs
= hfs_remount
,
184 .show_options
= hfs_show_options
,
188 opt_uid
, opt_gid
, opt_umask
, opt_file_umask
, opt_dir_umask
,
189 opt_part
, opt_session
, opt_type
, opt_creator
, opt_quiet
,
190 opt_codepage
, opt_iocharset
,
194 static const match_table_t tokens
= {
195 { opt_uid
, "uid=%u" },
196 { opt_gid
, "gid=%u" },
197 { opt_umask
, "umask=%o" },
198 { opt_file_umask
, "file_umask=%o" },
199 { opt_dir_umask
, "dir_umask=%o" },
200 { opt_part
, "part=%u" },
201 { opt_session
, "session=%u" },
202 { opt_type
, "type=%s" },
203 { opt_creator
, "creator=%s" },
204 { opt_quiet
, "quiet" },
205 { opt_codepage
, "codepage=%s" },
206 { opt_iocharset
, "iocharset=%s" },
210 static inline int match_fourchar(substring_t
*arg
, u32
*result
)
212 if (arg
->to
- arg
->from
!= 4)
214 memcpy(result
, arg
->from
, 4);
221 * adapted from linux/fs/msdos/inode.c written 1992,93 by Werner Almesberger
222 * This function is called by hfs_read_super() to parse the mount options.
224 static int parse_options(char *options
, struct hfs_sb_info
*hsb
)
227 substring_t args
[MAX_OPT_ARGS
];
230 /* initialize the sb with defaults */
231 hsb
->s_uid
= current_uid();
232 hsb
->s_gid
= current_gid();
233 hsb
->s_file_umask
= 0133;
234 hsb
->s_dir_umask
= 0022;
235 hsb
->s_type
= hsb
->s_creator
= cpu_to_be32(0x3f3f3f3f); /* == '????' */
243 while ((p
= strsep(&options
, ",")) != NULL
) {
247 token
= match_token(p
, tokens
, args
);
250 if (match_int(&args
[0], &tmp
)) {
251 printk(KERN_ERR
"hfs: uid requires an argument\n");
254 hsb
->s_uid
= (uid_t
)tmp
;
257 if (match_int(&args
[0], &tmp
)) {
258 printk(KERN_ERR
"hfs: gid requires an argument\n");
261 hsb
->s_gid
= (gid_t
)tmp
;
264 if (match_octal(&args
[0], &tmp
)) {
265 printk(KERN_ERR
"hfs: umask requires a value\n");
268 hsb
->s_file_umask
= (umode_t
)tmp
;
269 hsb
->s_dir_umask
= (umode_t
)tmp
;
272 if (match_octal(&args
[0], &tmp
)) {
273 printk(KERN_ERR
"hfs: file_umask requires a value\n");
276 hsb
->s_file_umask
= (umode_t
)tmp
;
279 if (match_octal(&args
[0], &tmp
)) {
280 printk(KERN_ERR
"hfs: dir_umask requires a value\n");
283 hsb
->s_dir_umask
= (umode_t
)tmp
;
286 if (match_int(&args
[0], &hsb
->part
)) {
287 printk(KERN_ERR
"hfs: part requires an argument\n");
292 if (match_int(&args
[0], &hsb
->session
)) {
293 printk(KERN_ERR
"hfs: session requires an argument\n");
298 if (match_fourchar(&args
[0], &hsb
->s_type
)) {
299 printk(KERN_ERR
"hfs: type requires a 4 character value\n");
304 if (match_fourchar(&args
[0], &hsb
->s_creator
)) {
305 printk(KERN_ERR
"hfs: creator requires a 4 character value\n");
314 printk(KERN_ERR
"hfs: unable to change codepage\n");
317 p
= match_strdup(&args
[0]);
319 hsb
->nls_disk
= load_nls(p
);
320 if (!hsb
->nls_disk
) {
321 printk(KERN_ERR
"hfs: unable to load codepage \"%s\"\n", p
);
329 printk(KERN_ERR
"hfs: unable to change iocharset\n");
332 p
= match_strdup(&args
[0]);
334 hsb
->nls_io
= load_nls(p
);
336 printk(KERN_ERR
"hfs: unable to load iocharset \"%s\"\n", p
);
347 if (hsb
->nls_disk
&& !hsb
->nls_io
) {
348 hsb
->nls_io
= load_nls_default();
350 printk(KERN_ERR
"hfs: unable to load default iocharset\n");
354 hsb
->s_dir_umask
&= 0777;
355 hsb
->s_file_umask
&= 0577;
363 * This is the function that is responsible for mounting an HFS
364 * filesystem. It performs all the tasks necessary to get enough data
365 * from the disk to read the root inode. This includes parsing the
366 * mount options, dealing with Macintosh partitions, reading the
367 * superblock and the allocation bitmap blocks, calling
368 * hfs_btree_init() to get the necessary data about the extents and
369 * catalog B-trees and, finally, reading the root inode into memory.
371 static int hfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
373 struct hfs_sb_info
*sbi
;
374 struct hfs_find_data fd
;
376 struct inode
*root_inode
;
379 sbi
= kzalloc(sizeof(struct hfs_sb_info
), GFP_KERNEL
);
387 if (!parse_options((char *)data
, sbi
)) {
388 printk(KERN_ERR
"hfs: unable to parse mount options.\n");
392 sb
->s_op
= &hfs_super_operations
;
393 sb
->s_flags
|= MS_NODIRATIME
;
394 mutex_init(&sbi
->bitmap_lock
);
396 res
= hfs_mdb_get(sb
);
399 printk(KERN_WARNING
"hfs: can't find a HFS filesystem on dev %s.\n",
405 /* try to get the root inode */
406 hfs_find_init(HFS_SB(sb
)->cat_tree
, &fd
);
407 res
= hfs_cat_find_brec(sb
, HFS_ROOT_CNID
, &fd
);
409 if (fd
.entrylength
> sizeof(rec
) || fd
.entrylength
< 0) {
413 hfs_bnode_read(fd
.bnode
, &rec
, fd
.entryoffset
, fd
.entrylength
);
420 root_inode
= hfs_iget(sb
, &fd
.search_key
->cat
, &rec
);
425 sb
->s_d_op
= &hfs_dentry_operations
;
427 sb
->s_root
= d_make_root(root_inode
);
431 /* everything's okay */
435 printk(KERN_ERR
"hfs: get root inode failed.\n");
441 static struct dentry
*hfs_mount(struct file_system_type
*fs_type
,
442 int flags
, const char *dev_name
, void *data
)
444 return mount_bdev(fs_type
, flags
, dev_name
, data
, hfs_fill_super
);
447 static struct file_system_type hfs_fs_type
= {
448 .owner
= THIS_MODULE
,
451 .kill_sb
= kill_block_super
,
452 .fs_flags
= FS_REQUIRES_DEV
,
455 static void hfs_init_once(void *p
)
457 struct hfs_inode_info
*i
= p
;
459 inode_init_once(&i
->vfs_inode
);
462 static int __init
init_hfs_fs(void)
466 hfs_inode_cachep
= kmem_cache_create("hfs_inode_cache",
467 sizeof(struct hfs_inode_info
), 0, SLAB_HWCACHE_ALIGN
,
469 if (!hfs_inode_cachep
)
471 err
= register_filesystem(&hfs_fs_type
);
473 kmem_cache_destroy(hfs_inode_cachep
);
477 static void __exit
exit_hfs_fs(void)
479 unregister_filesystem(&hfs_fs_type
);
480 kmem_cache_destroy(hfs_inode_cachep
);
483 module_init(init_hfs_fs
)
484 module_exit(exit_hfs_fs
)