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