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