xref: /openbmc/linux/fs/affs/super.c (revision 565d76cb)
1 /*
2  *  linux/fs/affs/inode.c
3  *
4  *  (c) 1996  Hans-Joachim Widmaier - Rewritten
5  *
6  *  (C) 1993  Ray Burr - Modified for Amiga FFS filesystem.
7  *
8  *  (C) 1992  Eric Youngdale Modified for ISO 9660 filesystem.
9  *
10  *  (C) 1991  Linus Torvalds - minix filesystem
11  */
12 
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/statfs.h>
16 #include <linux/parser.h>
17 #include <linux/magic.h>
18 #include <linux/sched.h>
19 #include <linux/slab.h>
20 #include "affs.h"
21 
22 extern struct timezone sys_tz;
23 
24 static int affs_statfs(struct dentry *dentry, struct kstatfs *buf);
25 static int affs_remount (struct super_block *sb, int *flags, char *data);
26 
27 static void
28 affs_commit_super(struct super_block *sb, int wait, int clean)
29 {
30 	struct affs_sb_info *sbi = AFFS_SB(sb);
31 	struct buffer_head *bh = sbi->s_root_bh;
32 	struct affs_root_tail *tail = AFFS_ROOT_TAIL(sb, bh);
33 
34 	tail->bm_flag = cpu_to_be32(clean);
35 	secs_to_datestamp(get_seconds(), &tail->disk_change);
36 	affs_fix_checksum(sb, bh);
37 	mark_buffer_dirty(bh);
38 	if (wait)
39 		sync_dirty_buffer(bh);
40 }
41 
42 static void
43 affs_put_super(struct super_block *sb)
44 {
45 	struct affs_sb_info *sbi = AFFS_SB(sb);
46 	pr_debug("AFFS: put_super()\n");
47 
48 	if (!(sb->s_flags & MS_RDONLY) && sb->s_dirt)
49 		affs_commit_super(sb, 1, 1);
50 
51 	kfree(sbi->s_prefix);
52 	affs_free_bitmap(sb);
53 	affs_brelse(sbi->s_root_bh);
54 	kfree(sbi);
55 	sb->s_fs_info = NULL;
56 }
57 
58 static void
59 affs_write_super(struct super_block *sb)
60 {
61 	lock_super(sb);
62 	if (!(sb->s_flags & MS_RDONLY))
63 		affs_commit_super(sb, 1, 2);
64 	sb->s_dirt = 0;
65 	unlock_super(sb);
66 
67 	pr_debug("AFFS: write_super() at %lu, clean=2\n", get_seconds());
68 }
69 
70 static int
71 affs_sync_fs(struct super_block *sb, int wait)
72 {
73 	lock_super(sb);
74 	affs_commit_super(sb, wait, 2);
75 	sb->s_dirt = 0;
76 	unlock_super(sb);
77 	return 0;
78 }
79 
80 static struct kmem_cache * affs_inode_cachep;
81 
82 static struct inode *affs_alloc_inode(struct super_block *sb)
83 {
84 	struct affs_inode_info *i;
85 
86 	i = kmem_cache_alloc(affs_inode_cachep, GFP_KERNEL);
87 	if (!i)
88 		return NULL;
89 
90 	i->vfs_inode.i_version = 1;
91 	i->i_lc = NULL;
92 	i->i_ext_bh = NULL;
93 	i->i_pa_cnt = 0;
94 
95 	return &i->vfs_inode;
96 }
97 
98 static void affs_i_callback(struct rcu_head *head)
99 {
100 	struct inode *inode = container_of(head, struct inode, i_rcu);
101 	INIT_LIST_HEAD(&inode->i_dentry);
102 	kmem_cache_free(affs_inode_cachep, AFFS_I(inode));
103 }
104 
105 static void affs_destroy_inode(struct inode *inode)
106 {
107 	call_rcu(&inode->i_rcu, affs_i_callback);
108 }
109 
110 static void init_once(void *foo)
111 {
112 	struct affs_inode_info *ei = (struct affs_inode_info *) foo;
113 
114 	sema_init(&ei->i_link_lock, 1);
115 	sema_init(&ei->i_ext_lock, 1);
116 	inode_init_once(&ei->vfs_inode);
117 }
118 
119 static int init_inodecache(void)
120 {
121 	affs_inode_cachep = kmem_cache_create("affs_inode_cache",
122 					     sizeof(struct affs_inode_info),
123 					     0, (SLAB_RECLAIM_ACCOUNT|
124 						SLAB_MEM_SPREAD),
125 					     init_once);
126 	if (affs_inode_cachep == NULL)
127 		return -ENOMEM;
128 	return 0;
129 }
130 
131 static void destroy_inodecache(void)
132 {
133 	kmem_cache_destroy(affs_inode_cachep);
134 }
135 
136 static const struct super_operations affs_sops = {
137 	.alloc_inode	= affs_alloc_inode,
138 	.destroy_inode	= affs_destroy_inode,
139 	.write_inode	= affs_write_inode,
140 	.evict_inode	= affs_evict_inode,
141 	.put_super	= affs_put_super,
142 	.write_super	= affs_write_super,
143 	.sync_fs	= affs_sync_fs,
144 	.statfs		= affs_statfs,
145 	.remount_fs	= affs_remount,
146 	.show_options	= generic_show_options,
147 };
148 
149 enum {
150 	Opt_bs, Opt_mode, Opt_mufs, Opt_prefix, Opt_protect,
151 	Opt_reserved, Opt_root, Opt_setgid, Opt_setuid,
152 	Opt_verbose, Opt_volume, Opt_ignore, Opt_err,
153 };
154 
155 static const match_table_t tokens = {
156 	{Opt_bs, "bs=%u"},
157 	{Opt_mode, "mode=%o"},
158 	{Opt_mufs, "mufs"},
159 	{Opt_prefix, "prefix=%s"},
160 	{Opt_protect, "protect"},
161 	{Opt_reserved, "reserved=%u"},
162 	{Opt_root, "root=%u"},
163 	{Opt_setgid, "setgid=%u"},
164 	{Opt_setuid, "setuid=%u"},
165 	{Opt_verbose, "verbose"},
166 	{Opt_volume, "volume=%s"},
167 	{Opt_ignore, "grpquota"},
168 	{Opt_ignore, "noquota"},
169 	{Opt_ignore, "quota"},
170 	{Opt_ignore, "usrquota"},
171 	{Opt_err, NULL},
172 };
173 
174 static int
175 parse_options(char *options, uid_t *uid, gid_t *gid, int *mode, int *reserved, s32 *root,
176 		int *blocksize, char **prefix, char *volume, unsigned long *mount_opts)
177 {
178 	char *p;
179 	substring_t args[MAX_OPT_ARGS];
180 
181 	/* Fill in defaults */
182 
183 	*uid        = current_uid();
184 	*gid        = current_gid();
185 	*reserved   = 2;
186 	*root       = -1;
187 	*blocksize  = -1;
188 	volume[0]   = ':';
189 	volume[1]   = 0;
190 	*mount_opts = 0;
191 	if (!options)
192 		return 1;
193 
194 	while ((p = strsep(&options, ",")) != NULL) {
195 		int token, n, option;
196 		if (!*p)
197 			continue;
198 
199 		token = match_token(p, tokens, args);
200 		switch (token) {
201 		case Opt_bs:
202 			if (match_int(&args[0], &n))
203 				return 0;
204 			if (n != 512 && n != 1024 && n != 2048
205 			    && n != 4096) {
206 				printk ("AFFS: Invalid blocksize (512, 1024, 2048, 4096 allowed)\n");
207 				return 0;
208 			}
209 			*blocksize = n;
210 			break;
211 		case Opt_mode:
212 			if (match_octal(&args[0], &option))
213 				return 0;
214 			*mode = option & 0777;
215 			*mount_opts |= SF_SETMODE;
216 			break;
217 		case Opt_mufs:
218 			*mount_opts |= SF_MUFS;
219 			break;
220 		case Opt_prefix:
221 			*prefix = match_strdup(&args[0]);
222 			if (!*prefix)
223 				return 0;
224 			*mount_opts |= SF_PREFIX;
225 			break;
226 		case Opt_protect:
227 			*mount_opts |= SF_IMMUTABLE;
228 			break;
229 		case Opt_reserved:
230 			if (match_int(&args[0], reserved))
231 				return 0;
232 			break;
233 		case Opt_root:
234 			if (match_int(&args[0], root))
235 				return 0;
236 			break;
237 		case Opt_setgid:
238 			if (match_int(&args[0], &option))
239 				return 0;
240 			*gid = option;
241 			*mount_opts |= SF_SETGID;
242 			break;
243 		case Opt_setuid:
244 			if (match_int(&args[0], &option))
245 				return 0;
246 			*uid = option;
247 			*mount_opts |= SF_SETUID;
248 			break;
249 		case Opt_verbose:
250 			*mount_opts |= SF_VERBOSE;
251 			break;
252 		case Opt_volume: {
253 			char *vol = match_strdup(&args[0]);
254 			if (!vol)
255 				return 0;
256 			strlcpy(volume, vol, 32);
257 			kfree(vol);
258 			break;
259 		}
260 		case Opt_ignore:
261 		 	/* Silently ignore the quota options */
262 			break;
263 		default:
264 			printk("AFFS: Unrecognized mount option \"%s\" "
265 					"or missing value\n", p);
266 			return 0;
267 		}
268 	}
269 	return 1;
270 }
271 
272 /* This function definitely needs to be split up. Some fine day I'll
273  * hopefully have the guts to do so. Until then: sorry for the mess.
274  */
275 
276 static int affs_fill_super(struct super_block *sb, void *data, int silent)
277 {
278 	struct affs_sb_info	*sbi;
279 	struct buffer_head	*root_bh = NULL;
280 	struct buffer_head	*boot_bh;
281 	struct inode		*root_inode = NULL;
282 	s32			 root_block;
283 	int			 size, blocksize;
284 	u32			 chksum;
285 	int			 num_bm;
286 	int			 i, j;
287 	s32			 key;
288 	uid_t			 uid;
289 	gid_t			 gid;
290 	int			 reserved;
291 	unsigned long		 mount_flags;
292 	int			 tmp_flags;	/* fix remount prototype... */
293 	u8			 sig[4];
294 	int			 ret = -EINVAL;
295 
296 	save_mount_options(sb, data);
297 
298 	pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
299 
300 	sb->s_magic             = AFFS_SUPER_MAGIC;
301 	sb->s_op                = &affs_sops;
302 	sb->s_flags |= MS_NODIRATIME;
303 
304 	sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
305 	if (!sbi)
306 		return -ENOMEM;
307 
308 	sb->s_fs_info = sbi;
309 	mutex_init(&sbi->s_bmlock);
310 	spin_lock_init(&sbi->symlink_lock);
311 
312 	if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
313 				&blocksize,&sbi->s_prefix,
314 				sbi->s_volume, &mount_flags)) {
315 		printk(KERN_ERR "AFFS: Error parsing options\n");
316 		kfree(sbi->s_prefix);
317 		kfree(sbi);
318 		return -EINVAL;
319 	}
320 	/* N.B. after this point s_prefix must be released */
321 
322 	sbi->s_flags   = mount_flags;
323 	sbi->s_mode    = i;
324 	sbi->s_uid     = uid;
325 	sbi->s_gid     = gid;
326 	sbi->s_reserved= reserved;
327 
328 	/* Get the size of the device in 512-byte blocks.
329 	 * If we later see that the partition uses bigger
330 	 * blocks, we will have to change it.
331 	 */
332 
333 	size = sb->s_bdev->bd_inode->i_size >> 9;
334 	pr_debug("AFFS: initial blocksize=%d, #blocks=%d\n", 512, size);
335 
336 	affs_set_blocksize(sb, PAGE_SIZE);
337 	/* Try to find root block. Its location depends on the block size. */
338 
339 	i = 512;
340 	j = 4096;
341 	if (blocksize > 0) {
342 		i = j = blocksize;
343 		size = size / (blocksize / 512);
344 	}
345 	for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
346 		sbi->s_root_block = root_block;
347 		if (root_block < 0)
348 			sbi->s_root_block = (reserved + size - 1) / 2;
349 		pr_debug("AFFS: setting blocksize to %d\n", blocksize);
350 		affs_set_blocksize(sb, blocksize);
351 		sbi->s_partition_size = size;
352 
353 		/* The root block location that was calculated above is not
354 		 * correct if the partition size is an odd number of 512-
355 		 * byte blocks, which will be rounded down to a number of
356 		 * 1024-byte blocks, and if there were an even number of
357 		 * reserved blocks. Ideally, all partition checkers should
358 		 * report the real number of blocks of the real blocksize,
359 		 * but since this just cannot be done, we have to try to
360 		 * find the root block anyways. In the above case, it is one
361 		 * block behind the calculated one. So we check this one, too.
362 		 */
363 		for (num_bm = 0; num_bm < 2; num_bm++) {
364 			pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
365 				"size=%d, reserved=%d\n",
366 				sb->s_id,
367 				sbi->s_root_block + num_bm,
368 				blocksize, size, reserved);
369 			root_bh = affs_bread(sb, sbi->s_root_block + num_bm);
370 			if (!root_bh)
371 				continue;
372 			if (!affs_checksum_block(sb, root_bh) &&
373 			    be32_to_cpu(AFFS_ROOT_HEAD(root_bh)->ptype) == T_SHORT &&
374 			    be32_to_cpu(AFFS_ROOT_TAIL(sb, root_bh)->stype) == ST_ROOT) {
375 				sbi->s_hashsize    = blocksize / 4 - 56;
376 				sbi->s_root_block += num_bm;
377 				key                        = 1;
378 				goto got_root;
379 			}
380 			affs_brelse(root_bh);
381 			root_bh = NULL;
382 		}
383 	}
384 	if (!silent)
385 		printk(KERN_ERR "AFFS: No valid root block on device %s\n",
386 			sb->s_id);
387 	goto out_error;
388 
389 	/* N.B. after this point bh must be released */
390 got_root:
391 	root_block = sbi->s_root_block;
392 
393 	/* Find out which kind of FS we have */
394 	boot_bh = sb_bread(sb, 0);
395 	if (!boot_bh) {
396 		printk(KERN_ERR "AFFS: Cannot read boot block\n");
397 		goto out_error;
398 	}
399 	memcpy(sig, boot_bh->b_data, 4);
400 	brelse(boot_bh);
401 	chksum = be32_to_cpu(*(__be32 *)sig);
402 
403 	/* Dircache filesystems are compatible with non-dircache ones
404 	 * when reading. As long as they aren't supported, writing is
405 	 * not recommended.
406 	 */
407 	if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
408 	     || chksum == MUFS_DCOFS) && !(sb->s_flags & MS_RDONLY)) {
409 		printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",
410 			sb->s_id);
411 		sb->s_flags |= MS_RDONLY;
412 	}
413 	switch (chksum) {
414 		case MUFS_FS:
415 		case MUFS_INTLFFS:
416 		case MUFS_DCFFS:
417 			sbi->s_flags |= SF_MUFS;
418 			/* fall thru */
419 		case FS_INTLFFS:
420 		case FS_DCFFS:
421 			sbi->s_flags |= SF_INTL;
422 			break;
423 		case MUFS_FFS:
424 			sbi->s_flags |= SF_MUFS;
425 			break;
426 		case FS_FFS:
427 			break;
428 		case MUFS_OFS:
429 			sbi->s_flags |= SF_MUFS;
430 			/* fall thru */
431 		case FS_OFS:
432 			sbi->s_flags |= SF_OFS;
433 			sb->s_flags |= MS_NOEXEC;
434 			break;
435 		case MUFS_DCOFS:
436 		case MUFS_INTLOFS:
437 			sbi->s_flags |= SF_MUFS;
438 		case FS_DCOFS:
439 		case FS_INTLOFS:
440 			sbi->s_flags |= SF_INTL | SF_OFS;
441 			sb->s_flags |= MS_NOEXEC;
442 			break;
443 		default:
444 			printk(KERN_ERR "AFFS: Unknown filesystem on device %s: %08X\n",
445 				sb->s_id, chksum);
446 			goto out_error;
447 	}
448 
449 	if (mount_flags & SF_VERBOSE) {
450 		u8 len = AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0];
451 		printk(KERN_NOTICE "AFFS: Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
452 			len > 31 ? 31 : len,
453 			AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,
454 			sig, sig[3] + '0', blocksize);
455 	}
456 
457 	sb->s_flags |= MS_NODEV | MS_NOSUID;
458 
459 	sbi->s_data_blksize = sb->s_blocksize;
460 	if (sbi->s_flags & SF_OFS)
461 		sbi->s_data_blksize -= 24;
462 
463 	/* Keep super block in cache */
464 	sbi->s_root_bh = root_bh;
465 	/* N.B. after this point s_root_bh must be released */
466 
467 	tmp_flags = sb->s_flags;
468 	if (affs_init_bitmap(sb, &tmp_flags))
469 		goto out_error;
470 	sb->s_flags = tmp_flags;
471 
472 	/* set up enough so that it can read an inode */
473 
474 	root_inode = affs_iget(sb, root_block);
475 	if (IS_ERR(root_inode)) {
476 		ret = PTR_ERR(root_inode);
477 		goto out_error_noinode;
478 	}
479 
480 	if (AFFS_SB(sb)->s_flags & SF_INTL)
481 		sb->s_d_op = &affs_intl_dentry_operations;
482 	else
483 		sb->s_d_op = &affs_dentry_operations;
484 
485 	sb->s_root = d_alloc_root(root_inode);
486 	if (!sb->s_root) {
487 		printk(KERN_ERR "AFFS: Get root inode failed\n");
488 		goto out_error;
489 	}
490 
491 	pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);
492 	return 0;
493 
494 	/*
495 	 * Begin the cascaded cleanup ...
496 	 */
497 out_error:
498 	if (root_inode)
499 		iput(root_inode);
500 out_error_noinode:
501 	kfree(sbi->s_bitmap);
502 	affs_brelse(root_bh);
503 	kfree(sbi->s_prefix);
504 	kfree(sbi);
505 	sb->s_fs_info = NULL;
506 	return ret;
507 }
508 
509 static int
510 affs_remount(struct super_block *sb, int *flags, char *data)
511 {
512 	struct affs_sb_info	*sbi = AFFS_SB(sb);
513 	int			 blocksize;
514 	uid_t			 uid;
515 	gid_t			 gid;
516 	int			 mode;
517 	int			 reserved;
518 	int			 root_block;
519 	unsigned long		 mount_flags;
520 	int			 res = 0;
521 	char			*new_opts = kstrdup(data, GFP_KERNEL);
522 	char			 volume[32];
523 	char			*prefix = NULL;
524 
525 	pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data);
526 
527 	*flags |= MS_NODIRATIME;
528 
529 	memcpy(volume, sbi->s_volume, 32);
530 	if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block,
531 			   &blocksize, &prefix, volume,
532 			   &mount_flags)) {
533 		kfree(prefix);
534 		kfree(new_opts);
535 		return -EINVAL;
536 	}
537 
538 	replace_mount_options(sb, new_opts);
539 
540 	sbi->s_flags = mount_flags;
541 	sbi->s_mode  = mode;
542 	sbi->s_uid   = uid;
543 	sbi->s_gid   = gid;
544 	/* protect against readers */
545 	spin_lock(&sbi->symlink_lock);
546 	if (prefix) {
547 		kfree(sbi->s_prefix);
548 		sbi->s_prefix = prefix;
549 	}
550 	memcpy(sbi->s_volume, volume, 32);
551 	spin_unlock(&sbi->symlink_lock);
552 
553 	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
554 		return 0;
555 
556 	if (*flags & MS_RDONLY) {
557 		affs_write_super(sb);
558 		affs_free_bitmap(sb);
559 	} else
560 		res = affs_init_bitmap(sb, flags);
561 
562 	return res;
563 }
564 
565 static int
566 affs_statfs(struct dentry *dentry, struct kstatfs *buf)
567 {
568 	struct super_block *sb = dentry->d_sb;
569 	int		 free;
570 	u64		 id = huge_encode_dev(sb->s_bdev->bd_dev);
571 
572 	pr_debug("AFFS: statfs() partsize=%d, reserved=%d\n",AFFS_SB(sb)->s_partition_size,
573 	     AFFS_SB(sb)->s_reserved);
574 
575 	free          = affs_count_free_blocks(sb);
576 	buf->f_type    = AFFS_SUPER_MAGIC;
577 	buf->f_bsize   = sb->s_blocksize;
578 	buf->f_blocks  = AFFS_SB(sb)->s_partition_size - AFFS_SB(sb)->s_reserved;
579 	buf->f_bfree   = free;
580 	buf->f_bavail  = free;
581 	buf->f_fsid.val[0] = (u32)id;
582 	buf->f_fsid.val[1] = (u32)(id >> 32);
583 	buf->f_namelen = 30;
584 	return 0;
585 }
586 
587 static struct dentry *affs_mount(struct file_system_type *fs_type,
588 	int flags, const char *dev_name, void *data)
589 {
590 	return mount_bdev(fs_type, flags, dev_name, data, affs_fill_super);
591 }
592 
593 static struct file_system_type affs_fs_type = {
594 	.owner		= THIS_MODULE,
595 	.name		= "affs",
596 	.mount		= affs_mount,
597 	.kill_sb	= kill_block_super,
598 	.fs_flags	= FS_REQUIRES_DEV,
599 };
600 
601 static int __init init_affs_fs(void)
602 {
603 	int err = init_inodecache();
604 	if (err)
605 		goto out1;
606 	err = register_filesystem(&affs_fs_type);
607 	if (err)
608 		goto out;
609 	return 0;
610 out:
611 	destroy_inodecache();
612 out1:
613 	return err;
614 }
615 
616 static void __exit exit_affs_fs(void)
617 {
618 	unregister_filesystem(&affs_fs_type);
619 	destroy_inodecache();
620 }
621 
622 MODULE_DESCRIPTION("Amiga filesystem support for Linux");
623 MODULE_LICENSE("GPL");
624 
625 module_init(init_affs_fs)
626 module_exit(exit_affs_fs)
627