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