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