1 | /* |
2 | * linux/fs/hfs/super.c |
3 | * |
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. |
7 | * |
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. |
11 | * |
12 | * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds |
13 | */ |
14 | |
15 | #include <linux/module.h> |
16 | #include <linux/blkdev.h> |
17 | #include <linux/backing-dev.h> |
18 | #include <linux/mount.h> |
19 | #include <linux/init.h> |
20 | #include <linux/nls.h> |
21 | #include <linux/parser.h> |
22 | #include <linux/seq_file.h> |
23 | #include <linux/slab.h> |
24 | #include <linux/vfs.h> |
25 | |
26 | #include "hfs_fs.h" |
27 | #include "btree.h" |
28 | |
29 | static struct kmem_cache *hfs_inode_cachep; |
30 | |
31 | MODULE_LICENSE("GPL" ); |
32 | |
33 | static int hfs_sync_fs(struct super_block *sb, int wait) |
34 | { |
35 | hfs_mdb_commit(sb); |
36 | return 0; |
37 | } |
38 | |
39 | /* |
40 | * hfs_put_super() |
41 | * |
42 | * This is the put_super() entry in the super_operations structure for |
43 | * HFS filesystems. The purpose is to release the resources |
44 | * associated with the superblock sb. |
45 | */ |
46 | static void hfs_put_super(struct super_block *sb) |
47 | { |
48 | cancel_delayed_work_sync(dwork: &HFS_SB(sb)->mdb_work); |
49 | hfs_mdb_close(sb); |
50 | /* release the MDB's resources */ |
51 | hfs_mdb_put(sb); |
52 | } |
53 | |
54 | static void flush_mdb(struct work_struct *work) |
55 | { |
56 | struct hfs_sb_info *sbi; |
57 | struct super_block *sb; |
58 | |
59 | sbi = container_of(work, struct hfs_sb_info, mdb_work.work); |
60 | sb = sbi->sb; |
61 | |
62 | spin_lock(lock: &sbi->work_lock); |
63 | sbi->work_queued = 0; |
64 | spin_unlock(lock: &sbi->work_lock); |
65 | |
66 | hfs_mdb_commit(sb); |
67 | } |
68 | |
69 | void hfs_mark_mdb_dirty(struct super_block *sb) |
70 | { |
71 | struct hfs_sb_info *sbi = HFS_SB(sb); |
72 | unsigned long delay; |
73 | |
74 | if (sb_rdonly(sb)) |
75 | return; |
76 | |
77 | spin_lock(lock: &sbi->work_lock); |
78 | if (!sbi->work_queued) { |
79 | delay = msecs_to_jiffies(m: dirty_writeback_interval * 10); |
80 | queue_delayed_work(wq: system_long_wq, dwork: &sbi->mdb_work, delay); |
81 | sbi->work_queued = 1; |
82 | } |
83 | spin_unlock(lock: &sbi->work_lock); |
84 | } |
85 | |
86 | /* |
87 | * hfs_statfs() |
88 | * |
89 | * This is the statfs() entry in the super_operations structure for |
90 | * HFS filesystems. The purpose is to return various data about the |
91 | * filesystem. |
92 | * |
93 | * changed f_files/f_ffree to reflect the fs_ablock/free_ablocks. |
94 | */ |
95 | static int hfs_statfs(struct dentry *dentry, struct kstatfs *buf) |
96 | { |
97 | struct super_block *sb = dentry->d_sb; |
98 | u64 id = huge_encode_dev(dev: sb->s_bdev->bd_dev); |
99 | |
100 | buf->f_type = HFS_SUPER_MAGIC; |
101 | buf->f_bsize = sb->s_blocksize; |
102 | buf->f_blocks = (u32)HFS_SB(sb)->fs_ablocks * HFS_SB(sb)->fs_div; |
103 | buf->f_bfree = (u32)HFS_SB(sb)->free_ablocks * HFS_SB(sb)->fs_div; |
104 | buf->f_bavail = buf->f_bfree; |
105 | buf->f_files = HFS_SB(sb)->fs_ablocks; |
106 | buf->f_ffree = HFS_SB(sb)->free_ablocks; |
107 | buf->f_fsid = u64_to_fsid(v: id); |
108 | buf->f_namelen = HFS_NAMELEN; |
109 | |
110 | return 0; |
111 | } |
112 | |
113 | static int hfs_remount(struct super_block *sb, int *flags, char *data) |
114 | { |
115 | sync_filesystem(sb); |
116 | *flags |= SB_NODIRATIME; |
117 | if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb)) |
118 | return 0; |
119 | if (!(*flags & SB_RDONLY)) { |
120 | if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) { |
121 | pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. leaving read-only.\n" ); |
122 | sb->s_flags |= SB_RDONLY; |
123 | *flags |= SB_RDONLY; |
124 | } else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) { |
125 | pr_warn("filesystem is marked locked, leaving read-only.\n" ); |
126 | sb->s_flags |= SB_RDONLY; |
127 | *flags |= SB_RDONLY; |
128 | } |
129 | } |
130 | return 0; |
131 | } |
132 | |
133 | static int hfs_show_options(struct seq_file *seq, struct dentry *root) |
134 | { |
135 | struct hfs_sb_info *sbi = HFS_SB(root->d_sb); |
136 | |
137 | if (sbi->s_creator != cpu_to_be32(0x3f3f3f3f)) |
138 | seq_show_option_n(seq, "creator" , (char *)&sbi->s_creator, 4); |
139 | if (sbi->s_type != cpu_to_be32(0x3f3f3f3f)) |
140 | seq_show_option_n(seq, "type" , (char *)&sbi->s_type, 4); |
141 | seq_printf(m: seq, fmt: ",uid=%u,gid=%u" , |
142 | from_kuid_munged(to: &init_user_ns, uid: sbi->s_uid), |
143 | from_kgid_munged(to: &init_user_ns, gid: sbi->s_gid)); |
144 | if (sbi->s_file_umask != 0133) |
145 | seq_printf(m: seq, fmt: ",file_umask=%o" , sbi->s_file_umask); |
146 | if (sbi->s_dir_umask != 0022) |
147 | seq_printf(m: seq, fmt: ",dir_umask=%o" , sbi->s_dir_umask); |
148 | if (sbi->part >= 0) |
149 | seq_printf(m: seq, fmt: ",part=%u" , sbi->part); |
150 | if (sbi->session >= 0) |
151 | seq_printf(m: seq, fmt: ",session=%u" , sbi->session); |
152 | if (sbi->nls_disk) |
153 | seq_printf(m: seq, fmt: ",codepage=%s" , sbi->nls_disk->charset); |
154 | if (sbi->nls_io) |
155 | seq_printf(m: seq, fmt: ",iocharset=%s" , sbi->nls_io->charset); |
156 | if (sbi->s_quiet) |
157 | seq_printf(m: seq, fmt: ",quiet" ); |
158 | return 0; |
159 | } |
160 | |
161 | static struct inode *hfs_alloc_inode(struct super_block *sb) |
162 | { |
163 | struct hfs_inode_info *i; |
164 | |
165 | i = alloc_inode_sb(sb, cache: hfs_inode_cachep, GFP_KERNEL); |
166 | return i ? &i->vfs_inode : NULL; |
167 | } |
168 | |
169 | static void hfs_free_inode(struct inode *inode) |
170 | { |
171 | kmem_cache_free(s: hfs_inode_cachep, HFS_I(inode)); |
172 | } |
173 | |
174 | static const struct super_operations hfs_super_operations = { |
175 | .alloc_inode = hfs_alloc_inode, |
176 | .free_inode = hfs_free_inode, |
177 | .write_inode = hfs_write_inode, |
178 | .evict_inode = hfs_evict_inode, |
179 | .put_super = hfs_put_super, |
180 | .sync_fs = hfs_sync_fs, |
181 | .statfs = hfs_statfs, |
182 | .remount_fs = hfs_remount, |
183 | .show_options = hfs_show_options, |
184 | }; |
185 | |
186 | enum { |
187 | opt_uid, opt_gid, opt_umask, opt_file_umask, opt_dir_umask, |
188 | opt_part, opt_session, opt_type, opt_creator, opt_quiet, |
189 | opt_codepage, opt_iocharset, |
190 | opt_err |
191 | }; |
192 | |
193 | static const match_table_t tokens = { |
194 | { opt_uid, "uid=%u" }, |
195 | { opt_gid, "gid=%u" }, |
196 | { opt_umask, "umask=%o" }, |
197 | { opt_file_umask, "file_umask=%o" }, |
198 | { opt_dir_umask, "dir_umask=%o" }, |
199 | { opt_part, "part=%u" }, |
200 | { opt_session, "session=%u" }, |
201 | { opt_type, "type=%s" }, |
202 | { opt_creator, "creator=%s" }, |
203 | { opt_quiet, "quiet" }, |
204 | { opt_codepage, "codepage=%s" }, |
205 | { opt_iocharset, "iocharset=%s" }, |
206 | { opt_err, NULL } |
207 | }; |
208 | |
209 | static inline int match_fourchar(substring_t *arg, u32 *result) |
210 | { |
211 | if (arg->to - arg->from != 4) |
212 | return -EINVAL; |
213 | memcpy(result, arg->from, 4); |
214 | return 0; |
215 | } |
216 | |
217 | /* |
218 | * parse_options() |
219 | * |
220 | * adapted from linux/fs/msdos/inode.c written 1992,93 by Werner Almesberger |
221 | * This function is called by hfs_read_super() to parse the mount options. |
222 | */ |
223 | static int parse_options(char *options, struct hfs_sb_info *hsb) |
224 | { |
225 | char *p; |
226 | substring_t args[MAX_OPT_ARGS]; |
227 | int tmp, token; |
228 | |
229 | /* initialize the sb with defaults */ |
230 | hsb->s_uid = current_uid(); |
231 | hsb->s_gid = current_gid(); |
232 | hsb->s_file_umask = 0133; |
233 | hsb->s_dir_umask = 0022; |
234 | hsb->s_type = hsb->s_creator = cpu_to_be32(0x3f3f3f3f); /* == '????' */ |
235 | hsb->s_quiet = 0; |
236 | hsb->part = -1; |
237 | hsb->session = -1; |
238 | |
239 | if (!options) |
240 | return 1; |
241 | |
242 | while ((p = strsep(&options, "," )) != NULL) { |
243 | if (!*p) |
244 | continue; |
245 | |
246 | token = match_token(p, table: tokens, args); |
247 | switch (token) { |
248 | case opt_uid: |
249 | if (match_int(&args[0], result: &tmp)) { |
250 | pr_err("uid requires an argument\n" ); |
251 | return 0; |
252 | } |
253 | hsb->s_uid = make_kuid(current_user_ns(), uid: (uid_t)tmp); |
254 | if (!uid_valid(uid: hsb->s_uid)) { |
255 | pr_err("invalid uid %d\n" , tmp); |
256 | return 0; |
257 | } |
258 | break; |
259 | case opt_gid: |
260 | if (match_int(&args[0], result: &tmp)) { |
261 | pr_err("gid requires an argument\n" ); |
262 | return 0; |
263 | } |
264 | hsb->s_gid = make_kgid(current_user_ns(), gid: (gid_t)tmp); |
265 | if (!gid_valid(gid: hsb->s_gid)) { |
266 | pr_err("invalid gid %d\n" , tmp); |
267 | return 0; |
268 | } |
269 | break; |
270 | case opt_umask: |
271 | if (match_octal(&args[0], result: &tmp)) { |
272 | pr_err("umask requires a value\n" ); |
273 | return 0; |
274 | } |
275 | hsb->s_file_umask = (umode_t)tmp; |
276 | hsb->s_dir_umask = (umode_t)tmp; |
277 | break; |
278 | case opt_file_umask: |
279 | if (match_octal(&args[0], result: &tmp)) { |
280 | pr_err("file_umask requires a value\n" ); |
281 | return 0; |
282 | } |
283 | hsb->s_file_umask = (umode_t)tmp; |
284 | break; |
285 | case opt_dir_umask: |
286 | if (match_octal(&args[0], result: &tmp)) { |
287 | pr_err("dir_umask requires a value\n" ); |
288 | return 0; |
289 | } |
290 | hsb->s_dir_umask = (umode_t)tmp; |
291 | break; |
292 | case opt_part: |
293 | if (match_int(&args[0], result: &hsb->part)) { |
294 | pr_err("part requires an argument\n" ); |
295 | return 0; |
296 | } |
297 | break; |
298 | case opt_session: |
299 | if (match_int(&args[0], result: &hsb->session)) { |
300 | pr_err("session requires an argument\n" ); |
301 | return 0; |
302 | } |
303 | break; |
304 | case opt_type: |
305 | if (match_fourchar(arg: &args[0], result: &hsb->s_type)) { |
306 | pr_err("type requires a 4 character value\n" ); |
307 | return 0; |
308 | } |
309 | break; |
310 | case opt_creator: |
311 | if (match_fourchar(arg: &args[0], result: &hsb->s_creator)) { |
312 | pr_err("creator requires a 4 character value\n" ); |
313 | return 0; |
314 | } |
315 | break; |
316 | case opt_quiet: |
317 | hsb->s_quiet = 1; |
318 | break; |
319 | case opt_codepage: |
320 | if (hsb->nls_disk) { |
321 | pr_err("unable to change codepage\n" ); |
322 | return 0; |
323 | } |
324 | p = match_strdup(&args[0]); |
325 | if (p) |
326 | hsb->nls_disk = load_nls(charset: p); |
327 | if (!hsb->nls_disk) { |
328 | pr_err("unable to load codepage \"%s\"\n" , p); |
329 | kfree(objp: p); |
330 | return 0; |
331 | } |
332 | kfree(objp: p); |
333 | break; |
334 | case opt_iocharset: |
335 | if (hsb->nls_io) { |
336 | pr_err("unable to change iocharset\n" ); |
337 | return 0; |
338 | } |
339 | p = match_strdup(&args[0]); |
340 | if (p) |
341 | hsb->nls_io = load_nls(charset: p); |
342 | if (!hsb->nls_io) { |
343 | pr_err("unable to load iocharset \"%s\"\n" , p); |
344 | kfree(objp: p); |
345 | return 0; |
346 | } |
347 | kfree(objp: p); |
348 | break; |
349 | default: |
350 | return 0; |
351 | } |
352 | } |
353 | |
354 | if (hsb->nls_disk && !hsb->nls_io) { |
355 | hsb->nls_io = load_nls_default(); |
356 | if (!hsb->nls_io) { |
357 | pr_err("unable to load default iocharset\n" ); |
358 | return 0; |
359 | } |
360 | } |
361 | hsb->s_dir_umask &= 0777; |
362 | hsb->s_file_umask &= 0577; |
363 | |
364 | return 1; |
365 | } |
366 | |
367 | /* |
368 | * hfs_read_super() |
369 | * |
370 | * This is the function that is responsible for mounting an HFS |
371 | * filesystem. It performs all the tasks necessary to get enough data |
372 | * from the disk to read the root inode. This includes parsing the |
373 | * mount options, dealing with Macintosh partitions, reading the |
374 | * superblock and the allocation bitmap blocks, calling |
375 | * hfs_btree_init() to get the necessary data about the extents and |
376 | * catalog B-trees and, finally, reading the root inode into memory. |
377 | */ |
378 | static int hfs_fill_super(struct super_block *sb, void *data, int silent) |
379 | { |
380 | struct hfs_sb_info *sbi; |
381 | struct hfs_find_data fd; |
382 | hfs_cat_rec rec; |
383 | struct inode *root_inode; |
384 | int res; |
385 | |
386 | sbi = kzalloc(size: sizeof(struct hfs_sb_info), GFP_KERNEL); |
387 | if (!sbi) |
388 | return -ENOMEM; |
389 | |
390 | sbi->sb = sb; |
391 | sb->s_fs_info = sbi; |
392 | spin_lock_init(&sbi->work_lock); |
393 | INIT_DELAYED_WORK(&sbi->mdb_work, flush_mdb); |
394 | |
395 | res = -EINVAL; |
396 | if (!parse_options(options: (char *)data, hsb: sbi)) { |
397 | pr_err("unable to parse mount options\n" ); |
398 | goto bail; |
399 | } |
400 | |
401 | sb->s_op = &hfs_super_operations; |
402 | sb->s_xattr = hfs_xattr_handlers; |
403 | sb->s_flags |= SB_NODIRATIME; |
404 | mutex_init(&sbi->bitmap_lock); |
405 | |
406 | res = hfs_mdb_get(sb); |
407 | if (res) { |
408 | if (!silent) |
409 | pr_warn("can't find a HFS filesystem on dev %s\n" , |
410 | hfs_mdb_name(sb)); |
411 | res = -EINVAL; |
412 | goto bail; |
413 | } |
414 | |
415 | /* try to get the root inode */ |
416 | res = hfs_find_init(HFS_SB(sb)->cat_tree, &fd); |
417 | if (res) |
418 | goto bail_no_root; |
419 | res = hfs_cat_find_brec(sb, HFS_ROOT_CNID, &fd); |
420 | if (!res) { |
421 | if (fd.entrylength > sizeof(rec) || fd.entrylength < 0) { |
422 | res = -EIO; |
423 | goto bail_hfs_find; |
424 | } |
425 | hfs_bnode_read(fd.bnode, &rec, fd.entryoffset, fd.entrylength); |
426 | } |
427 | if (res) |
428 | goto bail_hfs_find; |
429 | res = -EINVAL; |
430 | root_inode = hfs_iget(sb, &fd.search_key->cat, &rec); |
431 | hfs_find_exit(&fd); |
432 | if (!root_inode) |
433 | goto bail_no_root; |
434 | |
435 | sb->s_d_op = &hfs_dentry_operations; |
436 | res = -ENOMEM; |
437 | sb->s_root = d_make_root(root_inode); |
438 | if (!sb->s_root) |
439 | goto bail_no_root; |
440 | |
441 | /* everything's okay */ |
442 | return 0; |
443 | |
444 | bail_hfs_find: |
445 | hfs_find_exit(&fd); |
446 | bail_no_root: |
447 | pr_err("get root inode failed\n" ); |
448 | bail: |
449 | hfs_mdb_put(sb); |
450 | return res; |
451 | } |
452 | |
453 | static struct dentry *hfs_mount(struct file_system_type *fs_type, |
454 | int flags, const char *dev_name, void *data) |
455 | { |
456 | return mount_bdev(fs_type, flags, dev_name, data, fill_super: hfs_fill_super); |
457 | } |
458 | |
459 | static struct file_system_type hfs_fs_type = { |
460 | .owner = THIS_MODULE, |
461 | .name = "hfs" , |
462 | .mount = hfs_mount, |
463 | .kill_sb = kill_block_super, |
464 | .fs_flags = FS_REQUIRES_DEV, |
465 | }; |
466 | MODULE_ALIAS_FS("hfs" ); |
467 | |
468 | static void hfs_init_once(void *p) |
469 | { |
470 | struct hfs_inode_info *i = p; |
471 | |
472 | inode_init_once(&i->vfs_inode); |
473 | } |
474 | |
475 | static int __init init_hfs_fs(void) |
476 | { |
477 | int err; |
478 | |
479 | hfs_inode_cachep = kmem_cache_create(name: "hfs_inode_cache" , |
480 | size: sizeof(struct hfs_inode_info), align: 0, |
481 | SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT, ctor: hfs_init_once); |
482 | if (!hfs_inode_cachep) |
483 | return -ENOMEM; |
484 | err = register_filesystem(&hfs_fs_type); |
485 | if (err) |
486 | kmem_cache_destroy(s: hfs_inode_cachep); |
487 | return err; |
488 | } |
489 | |
490 | static void __exit exit_hfs_fs(void) |
491 | { |
492 | unregister_filesystem(&hfs_fs_type); |
493 | |
494 | /* |
495 | * Make sure all delayed rcu free inodes are flushed before we |
496 | * destroy cache. |
497 | */ |
498 | rcu_barrier(); |
499 | kmem_cache_destroy(s: hfs_inode_cachep); |
500 | } |
501 | |
502 | module_init(init_hfs_fs) |
503 | module_exit(exit_hfs_fs) |
504 | |