xref: /openbmc/linux/fs/affs/super.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
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 "affs.h"
19 
20 extern struct timezone sys_tz;
21 
22 static int affs_statfs(struct dentry *dentry, struct kstatfs *buf);
23 static int affs_remount (struct super_block *sb, int *flags, char *data);
24 
25 static void
26 affs_put_super(struct super_block *sb)
27 {
28 	struct affs_sb_info *sbi = AFFS_SB(sb);
29 	pr_debug("AFFS: put_super()\n");
30 
31 	if (!(sb->s_flags & MS_RDONLY)) {
32 		AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag = cpu_to_be32(1);
33 		secs_to_datestamp(get_seconds(),
34 				  &AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->disk_change);
35 		affs_fix_checksum(sb, sbi->s_root_bh);
36 		mark_buffer_dirty(sbi->s_root_bh);
37 	}
38 
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 struct kmem_cache * 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, GFP_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, struct kmem_cache * cachep, unsigned long flags)
87 {
88 	struct affs_inode_info *ei = (struct affs_inode_info *) foo;
89 
90 	if (flags & SLAB_CTOR_CONSTRUCTOR) {
91 		init_MUTEX(&ei->i_link_lock);
92 		init_MUTEX(&ei->i_ext_lock);
93 		inode_init_once(&ei->vfs_inode);
94 	}
95 }
96 
97 static int init_inodecache(void)
98 {
99 	affs_inode_cachep = kmem_cache_create("affs_inode_cache",
100 					     sizeof(struct affs_inode_info),
101 					     0, (SLAB_RECLAIM_ACCOUNT|
102 						SLAB_MEM_SPREAD),
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 	kmem_cache_destroy(affs_inode_cachep);
112 }
113 
114 static const struct super_operations affs_sops = {
115 	.alloc_inode	= affs_alloc_inode,
116 	.destroy_inode	= affs_destroy_inode,
117 	.read_inode	= affs_read_inode,
118 	.write_inode	= affs_write_inode,
119 	.put_inode	= affs_put_inode,
120 	.drop_inode	= affs_drop_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 			/* Free any previous prefix */
202 			kfree(*prefix);
203 			*prefix = NULL;
204 			*prefix = match_strdup(&args[0]);
205 			if (!*prefix)
206 				return 0;
207 			*mount_opts |= SF_PREFIX;
208 			break;
209 		case Opt_protect:
210 			*mount_opts |= SF_IMMUTABLE;
211 			break;
212 		case Opt_reserved:
213 			if (match_int(&args[0], reserved))
214 				return 1;
215 			break;
216 		case Opt_root:
217 			if (match_int(&args[0], root))
218 				return 1;
219 			break;
220 		case Opt_setgid:
221 			if (match_int(&args[0], &option))
222 				return 1;
223 			*gid = option;
224 			*mount_opts |= SF_SETGID;
225 			break;
226 		case Opt_setuid:
227 			if (match_int(&args[0], &option))
228 				return -EINVAL;
229 			*uid = option;
230 			*mount_opts |= SF_SETUID;
231 			break;
232 		case Opt_verbose:
233 			*mount_opts |= SF_VERBOSE;
234 			break;
235 		case Opt_volume: {
236 			char *vol = match_strdup(&args[0]);
237 			strlcpy(volume, vol, 32);
238 			kfree(vol);
239 			break;
240 		}
241 		case Opt_ignore:
242 		 	/* Silently ignore the quota options */
243 			break;
244 		default:
245 			printk("AFFS: Unrecognized mount option \"%s\" "
246 					"or missing value\n", p);
247 			return 0;
248 		}
249 	}
250 	return 1;
251 }
252 
253 /* This function definitely needs to be split up. Some fine day I'll
254  * hopefully have the guts to do so. Until then: sorry for the mess.
255  */
256 
257 static int affs_fill_super(struct super_block *sb, void *data, int silent)
258 {
259 	struct affs_sb_info	*sbi;
260 	struct buffer_head	*root_bh = NULL;
261 	struct buffer_head	*boot_bh;
262 	struct inode		*root_inode = NULL;
263 	s32			 root_block;
264 	int			 size, blocksize;
265 	u32			 chksum;
266 	int			 num_bm;
267 	int			 i, j;
268 	s32			 key;
269 	uid_t			 uid;
270 	gid_t			 gid;
271 	int			 reserved;
272 	unsigned long		 mount_flags;
273 	int			 tmp_flags;	/* fix remount prototype... */
274 	u8			 sig[4];
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 = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
283 	if (!sbi)
284 		return -ENOMEM;
285 	sb->s_fs_info = sbi;
286 	init_MUTEX(&sbi->s_bmlock);
287 
288 	if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
289 				&blocksize,&sbi->s_prefix,
290 				sbi->s_volume, &mount_flags)) {
291 		printk(KERN_ERR "AFFS: Error parsing options\n");
292 		return -EINVAL;
293 	}
294 	/* N.B. after this point s_prefix must be released */
295 
296 	sbi->s_flags   = mount_flags;
297 	sbi->s_mode    = i;
298 	sbi->s_uid     = uid;
299 	sbi->s_gid     = gid;
300 	sbi->s_reserved= reserved;
301 
302 	/* Get the size of the device in 512-byte blocks.
303 	 * If we later see that the partition uses bigger
304 	 * blocks, we will have to change it.
305 	 */
306 
307 	size = sb->s_bdev->bd_inode->i_size >> 9;
308 	pr_debug("AFFS: initial blocksize=%d, #blocks=%d\n", 512, size);
309 
310 	affs_set_blocksize(sb, PAGE_SIZE);
311 	/* Try to find root block. Its location depends on the block size. */
312 
313 	i = 512;
314 	j = 4096;
315 	if (blocksize > 0) {
316 		i = j = blocksize;
317 		size = size / (blocksize / 512);
318 	}
319 	for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
320 		sbi->s_root_block = root_block;
321 		if (root_block < 0)
322 			sbi->s_root_block = (reserved + size - 1) / 2;
323 		pr_debug("AFFS: setting blocksize to %d\n", blocksize);
324 		affs_set_blocksize(sb, blocksize);
325 		sbi->s_partition_size = size;
326 
327 		/* The root block location that was calculated above is not
328 		 * correct if the partition size is an odd number of 512-
329 		 * byte blocks, which will be rounded down to a number of
330 		 * 1024-byte blocks, and if there were an even number of
331 		 * reserved blocks. Ideally, all partition checkers should
332 		 * report the real number of blocks of the real blocksize,
333 		 * but since this just cannot be done, we have to try to
334 		 * find the root block anyways. In the above case, it is one
335 		 * block behind the calculated one. So we check this one, too.
336 		 */
337 		for (num_bm = 0; num_bm < 2; num_bm++) {
338 			pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
339 				"size=%d, reserved=%d\n",
340 				sb->s_id,
341 				sbi->s_root_block + num_bm,
342 				blocksize, size, reserved);
343 			root_bh = affs_bread(sb, sbi->s_root_block + num_bm);
344 			if (!root_bh)
345 				continue;
346 			if (!affs_checksum_block(sb, root_bh) &&
347 			    be32_to_cpu(AFFS_ROOT_HEAD(root_bh)->ptype) == T_SHORT &&
348 			    be32_to_cpu(AFFS_ROOT_TAIL(sb, root_bh)->stype) == ST_ROOT) {
349 				sbi->s_hashsize    = blocksize / 4 - 56;
350 				sbi->s_root_block += num_bm;
351 				key                        = 1;
352 				goto got_root;
353 			}
354 			affs_brelse(root_bh);
355 			root_bh = NULL;
356 		}
357 	}
358 	if (!silent)
359 		printk(KERN_ERR "AFFS: No valid root block on device %s\n",
360 			sb->s_id);
361 	goto out_error;
362 
363 	/* N.B. after this point bh must be released */
364 got_root:
365 	root_block = sbi->s_root_block;
366 
367 	/* Find out which kind of FS we have */
368 	boot_bh = sb_bread(sb, 0);
369 	if (!boot_bh) {
370 		printk(KERN_ERR "AFFS: Cannot read boot block\n");
371 		goto out_error;
372 	}
373 	memcpy(sig, boot_bh->b_data, 4);
374 	brelse(boot_bh);
375 	chksum = be32_to_cpu(*(__be32 *)sig);
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 		u8 len = AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0];
425 		printk(KERN_NOTICE "AFFS: Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
426 			len > 31 ? 31 : len,
427 			AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,
428 			sig, sig[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 	kfree(sbi->s_bitmap);
466 	affs_brelse(root_bh);
467 	kfree(sbi->s_prefix);
468 	kfree(sbi);
469 	sb->s_fs_info = NULL;
470 	return -EINVAL;
471 }
472 
473 static int
474 affs_remount(struct super_block *sb, int *flags, char *data)
475 {
476 	struct affs_sb_info	*sbi = AFFS_SB(sb);
477 	int			 blocksize;
478 	uid_t			 uid;
479 	gid_t			 gid;
480 	int			 mode;
481 	int			 reserved;
482 	int			 root_block;
483 	unsigned long		 mount_flags;
484 	int			 res = 0;
485 
486 	pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data);
487 
488 	*flags |= MS_NODIRATIME;
489 
490 	if (!parse_options(data,&uid,&gid,&mode,&reserved,&root_block,
491 	    &blocksize,&sbi->s_prefix,sbi->s_volume,&mount_flags))
492 		return -EINVAL;
493 	sbi->s_flags = mount_flags;
494 	sbi->s_mode  = mode;
495 	sbi->s_uid   = uid;
496 	sbi->s_gid   = gid;
497 
498 	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
499 		return 0;
500 	if (*flags & MS_RDONLY) {
501 		sb->s_dirt = 1;
502 		while (sb->s_dirt)
503 			affs_write_super(sb);
504 		affs_free_bitmap(sb);
505 	} else
506 		res = affs_init_bitmap(sb, flags);
507 
508 	return res;
509 }
510 
511 static int
512 affs_statfs(struct dentry *dentry, struct kstatfs *buf)
513 {
514 	struct super_block *sb = dentry->d_sb;
515 	int		 free;
516 
517 	pr_debug("AFFS: statfs() partsize=%d, reserved=%d\n",AFFS_SB(sb)->s_partition_size,
518 	     AFFS_SB(sb)->s_reserved);
519 
520 	free          = affs_count_free_blocks(sb);
521 	buf->f_type    = AFFS_SUPER_MAGIC;
522 	buf->f_bsize   = sb->s_blocksize;
523 	buf->f_blocks  = AFFS_SB(sb)->s_partition_size - AFFS_SB(sb)->s_reserved;
524 	buf->f_bfree   = free;
525 	buf->f_bavail  = free;
526 	return 0;
527 }
528 
529 static int affs_get_sb(struct file_system_type *fs_type,
530 	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
531 {
532 	return get_sb_bdev(fs_type, flags, dev_name, data, affs_fill_super,
533 			   mnt);
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