1 /* 2 * super.c - NILFS module and super block management. 3 * 4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Written by Ryusuke Konishi <ryusuke@osrg.net> 21 */ 22 /* 23 * linux/fs/ext2/super.c 24 * 25 * Copyright (C) 1992, 1993, 1994, 1995 26 * Remy Card (card@masi.ibp.fr) 27 * Laboratoire MASI - Institut Blaise Pascal 28 * Universite Pierre et Marie Curie (Paris VI) 29 * 30 * from 31 * 32 * linux/fs/minix/inode.c 33 * 34 * Copyright (C) 1991, 1992 Linus Torvalds 35 * 36 * Big-endian to little-endian byte-swapping/bitmaps by 37 * David S. Miller (davem@caip.rutgers.edu), 1995 38 */ 39 40 #include <linux/module.h> 41 #include <linux/string.h> 42 #include <linux/slab.h> 43 #include <linux/init.h> 44 #include <linux/blkdev.h> 45 #include <linux/parser.h> 46 #include <linux/random.h> 47 #include <linux/crc32.h> 48 #include <linux/smp_lock.h> 49 #include <linux/vfs.h> 50 #include <linux/writeback.h> 51 #include <linux/kobject.h> 52 #include <linux/exportfs.h> 53 #include <linux/seq_file.h> 54 #include <linux/mount.h> 55 #include "nilfs.h" 56 #include "mdt.h" 57 #include "alloc.h" 58 #include "btree.h" 59 #include "btnode.h" 60 #include "page.h" 61 #include "cpfile.h" 62 #include "ifile.h" 63 #include "dat.h" 64 #include "segment.h" 65 #include "segbuf.h" 66 67 MODULE_AUTHOR("NTT Corp."); 68 MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem " 69 "(NILFS)"); 70 MODULE_LICENSE("GPL"); 71 72 struct kmem_cache *nilfs_inode_cachep; 73 struct kmem_cache *nilfs_transaction_cachep; 74 struct kmem_cache *nilfs_segbuf_cachep; 75 struct kmem_cache *nilfs_btree_path_cache; 76 77 static int nilfs_remount(struct super_block *sb, int *flags, char *data); 78 79 static void nilfs_set_error(struct nilfs_sb_info *sbi) 80 { 81 struct the_nilfs *nilfs = sbi->s_nilfs; 82 struct nilfs_super_block **sbp; 83 84 down_write(&nilfs->ns_sem); 85 if (!(nilfs->ns_mount_state & NILFS_ERROR_FS)) { 86 nilfs->ns_mount_state |= NILFS_ERROR_FS; 87 sbp = nilfs_prepare_super(sbi, 0); 88 if (likely(sbp)) { 89 sbp[0]->s_state |= cpu_to_le16(NILFS_ERROR_FS); 90 if (sbp[1]) 91 sbp[1]->s_state |= cpu_to_le16(NILFS_ERROR_FS); 92 nilfs_commit_super(sbi, NILFS_SB_COMMIT_ALL); 93 } 94 } 95 up_write(&nilfs->ns_sem); 96 } 97 98 /** 99 * nilfs_error() - report failure condition on a filesystem 100 * 101 * nilfs_error() sets an ERROR_FS flag on the superblock as well as 102 * reporting an error message. It should be called when NILFS detects 103 * incoherences or defects of meta data on disk. As for sustainable 104 * errors such as a single-shot I/O error, nilfs_warning() or the printk() 105 * function should be used instead. 106 * 107 * The segment constructor must not call this function because it can 108 * kill itself. 109 */ 110 void nilfs_error(struct super_block *sb, const char *function, 111 const char *fmt, ...) 112 { 113 struct nilfs_sb_info *sbi = NILFS_SB(sb); 114 va_list args; 115 116 va_start(args, fmt); 117 printk(KERN_CRIT "NILFS error (device %s): %s: ", sb->s_id, function); 118 vprintk(fmt, args); 119 printk("\n"); 120 va_end(args); 121 122 if (!(sb->s_flags & MS_RDONLY)) { 123 nilfs_set_error(sbi); 124 125 if (nilfs_test_opt(sbi, ERRORS_RO)) { 126 printk(KERN_CRIT "Remounting filesystem read-only\n"); 127 sb->s_flags |= MS_RDONLY; 128 } 129 } 130 131 if (nilfs_test_opt(sbi, ERRORS_PANIC)) 132 panic("NILFS (device %s): panic forced after error\n", 133 sb->s_id); 134 } 135 136 void nilfs_warning(struct super_block *sb, const char *function, 137 const char *fmt, ...) 138 { 139 va_list args; 140 141 va_start(args, fmt); 142 printk(KERN_WARNING "NILFS warning (device %s): %s: ", 143 sb->s_id, function); 144 vprintk(fmt, args); 145 printk("\n"); 146 va_end(args); 147 } 148 149 150 struct inode *nilfs_alloc_inode_common(struct the_nilfs *nilfs) 151 { 152 struct nilfs_inode_info *ii; 153 154 ii = kmem_cache_alloc(nilfs_inode_cachep, GFP_NOFS); 155 if (!ii) 156 return NULL; 157 ii->i_bh = NULL; 158 ii->i_state = 0; 159 ii->vfs_inode.i_version = 1; 160 nilfs_btnode_cache_init(&ii->i_btnode_cache, nilfs->ns_bdi); 161 return &ii->vfs_inode; 162 } 163 164 struct inode *nilfs_alloc_inode(struct super_block *sb) 165 { 166 return nilfs_alloc_inode_common(NILFS_SB(sb)->s_nilfs); 167 } 168 169 void nilfs_destroy_inode(struct inode *inode) 170 { 171 kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode)); 172 } 173 174 static int nilfs_sync_super(struct nilfs_sb_info *sbi, int flag) 175 { 176 struct the_nilfs *nilfs = sbi->s_nilfs; 177 int err; 178 int barrier_done = 0; 179 180 if (nilfs_test_opt(sbi, BARRIER)) { 181 set_buffer_ordered(nilfs->ns_sbh[0]); 182 barrier_done = 1; 183 } 184 retry: 185 set_buffer_dirty(nilfs->ns_sbh[0]); 186 err = sync_dirty_buffer(nilfs->ns_sbh[0]); 187 if (err == -EOPNOTSUPP && barrier_done) { 188 nilfs_warning(sbi->s_super, __func__, 189 "barrier-based sync failed. " 190 "disabling barriers\n"); 191 nilfs_clear_opt(sbi, BARRIER); 192 barrier_done = 0; 193 clear_buffer_ordered(nilfs->ns_sbh[0]); 194 goto retry; 195 } 196 if (unlikely(err)) { 197 printk(KERN_ERR 198 "NILFS: unable to write superblock (err=%d)\n", err); 199 if (err == -EIO && nilfs->ns_sbh[1]) { 200 /* 201 * sbp[0] points to newer log than sbp[1], 202 * so copy sbp[0] to sbp[1] to take over sbp[0]. 203 */ 204 memcpy(nilfs->ns_sbp[1], nilfs->ns_sbp[0], 205 nilfs->ns_sbsize); 206 nilfs_fall_back_super_block(nilfs); 207 goto retry; 208 } 209 } else { 210 struct nilfs_super_block *sbp = nilfs->ns_sbp[0]; 211 212 nilfs->ns_sbwcount++; 213 214 /* 215 * The latest segment becomes trailable from the position 216 * written in superblock. 217 */ 218 clear_nilfs_discontinued(nilfs); 219 220 /* update GC protection for recent segments */ 221 if (nilfs->ns_sbh[1]) { 222 if (flag == NILFS_SB_COMMIT_ALL) { 223 set_buffer_dirty(nilfs->ns_sbh[1]); 224 if (sync_dirty_buffer(nilfs->ns_sbh[1]) < 0) 225 goto out; 226 } 227 if (le64_to_cpu(nilfs->ns_sbp[1]->s_last_cno) < 228 le64_to_cpu(nilfs->ns_sbp[0]->s_last_cno)) 229 sbp = nilfs->ns_sbp[1]; 230 } 231 232 spin_lock(&nilfs->ns_last_segment_lock); 233 nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq); 234 spin_unlock(&nilfs->ns_last_segment_lock); 235 } 236 out: 237 return err; 238 } 239 240 void nilfs_set_log_cursor(struct nilfs_super_block *sbp, 241 struct the_nilfs *nilfs) 242 { 243 sector_t nfreeblocks; 244 245 /* nilfs->ns_sem must be locked by the caller. */ 246 nilfs_count_free_blocks(nilfs, &nfreeblocks); 247 sbp->s_free_blocks_count = cpu_to_le64(nfreeblocks); 248 249 spin_lock(&nilfs->ns_last_segment_lock); 250 sbp->s_last_seq = cpu_to_le64(nilfs->ns_last_seq); 251 sbp->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg); 252 sbp->s_last_cno = cpu_to_le64(nilfs->ns_last_cno); 253 spin_unlock(&nilfs->ns_last_segment_lock); 254 } 255 256 struct nilfs_super_block **nilfs_prepare_super(struct nilfs_sb_info *sbi, 257 int flip) 258 { 259 struct the_nilfs *nilfs = sbi->s_nilfs; 260 struct nilfs_super_block **sbp = nilfs->ns_sbp; 261 262 /* nilfs->ns_sem must be locked by the caller. */ 263 if (sbp[0]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 264 if (sbp[1] && 265 sbp[1]->s_magic == cpu_to_le16(NILFS_SUPER_MAGIC)) { 266 memcpy(sbp[0], sbp[1], nilfs->ns_sbsize); 267 } else { 268 printk(KERN_CRIT "NILFS: superblock broke on dev %s\n", 269 sbi->s_super->s_id); 270 return NULL; 271 } 272 } else if (sbp[1] && 273 sbp[1]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 274 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 275 } 276 277 if (flip && sbp[1]) 278 nilfs_swap_super_block(nilfs); 279 280 return sbp; 281 } 282 283 int nilfs_commit_super(struct nilfs_sb_info *sbi, int flag) 284 { 285 struct the_nilfs *nilfs = sbi->s_nilfs; 286 struct nilfs_super_block **sbp = nilfs->ns_sbp; 287 time_t t; 288 289 /* nilfs->ns_sem must be locked by the caller. */ 290 t = get_seconds(); 291 nilfs->ns_sbwtime = t; 292 sbp[0]->s_wtime = cpu_to_le64(t); 293 sbp[0]->s_sum = 0; 294 sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 295 (unsigned char *)sbp[0], 296 nilfs->ns_sbsize)); 297 if (flag == NILFS_SB_COMMIT_ALL && sbp[1]) { 298 sbp[1]->s_wtime = sbp[0]->s_wtime; 299 sbp[1]->s_sum = 0; 300 sbp[1]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 301 (unsigned char *)sbp[1], 302 nilfs->ns_sbsize)); 303 } 304 clear_nilfs_sb_dirty(nilfs); 305 return nilfs_sync_super(sbi, flag); 306 } 307 308 /** 309 * nilfs_cleanup_super() - write filesystem state for cleanup 310 * @sbi: nilfs_sb_info to be unmounted or degraded to read-only 311 * 312 * This function restores state flags in the on-disk super block. 313 * This will set "clean" flag (i.e. NILFS_VALID_FS) unless the 314 * filesystem was not clean previously. 315 */ 316 int nilfs_cleanup_super(struct nilfs_sb_info *sbi) 317 { 318 struct nilfs_super_block **sbp; 319 int flag = NILFS_SB_COMMIT; 320 int ret = -EIO; 321 322 sbp = nilfs_prepare_super(sbi, 0); 323 if (sbp) { 324 sbp[0]->s_state = cpu_to_le16(sbi->s_nilfs->ns_mount_state); 325 nilfs_set_log_cursor(sbp[0], sbi->s_nilfs); 326 if (sbp[1] && sbp[0]->s_last_cno == sbp[1]->s_last_cno) { 327 /* 328 * make the "clean" flag also to the opposite 329 * super block if both super blocks point to 330 * the same checkpoint. 331 */ 332 sbp[1]->s_state = sbp[0]->s_state; 333 flag = NILFS_SB_COMMIT_ALL; 334 } 335 ret = nilfs_commit_super(sbi, flag); 336 } 337 return ret; 338 } 339 340 static void nilfs_put_super(struct super_block *sb) 341 { 342 struct nilfs_sb_info *sbi = NILFS_SB(sb); 343 struct the_nilfs *nilfs = sbi->s_nilfs; 344 345 lock_kernel(); 346 347 nilfs_detach_segment_constructor(sbi); 348 349 if (!(sb->s_flags & MS_RDONLY)) { 350 down_write(&nilfs->ns_sem); 351 nilfs_cleanup_super(sbi); 352 up_write(&nilfs->ns_sem); 353 } 354 down_write(&nilfs->ns_super_sem); 355 if (nilfs->ns_current == sbi) 356 nilfs->ns_current = NULL; 357 up_write(&nilfs->ns_super_sem); 358 359 nilfs_detach_checkpoint(sbi); 360 put_nilfs(sbi->s_nilfs); 361 sbi->s_super = NULL; 362 sb->s_fs_info = NULL; 363 nilfs_put_sbinfo(sbi); 364 365 unlock_kernel(); 366 } 367 368 static int nilfs_sync_fs(struct super_block *sb, int wait) 369 { 370 struct nilfs_sb_info *sbi = NILFS_SB(sb); 371 struct the_nilfs *nilfs = sbi->s_nilfs; 372 struct nilfs_super_block **sbp; 373 int err = 0; 374 375 /* This function is called when super block should be written back */ 376 if (wait) 377 err = nilfs_construct_segment(sb); 378 379 down_write(&nilfs->ns_sem); 380 if (nilfs_sb_dirty(nilfs)) { 381 sbp = nilfs_prepare_super(sbi, nilfs_sb_will_flip(nilfs)); 382 if (likely(sbp)) { 383 nilfs_set_log_cursor(sbp[0], nilfs); 384 nilfs_commit_super(sbi, NILFS_SB_COMMIT); 385 } 386 } 387 up_write(&nilfs->ns_sem); 388 389 return err; 390 } 391 392 int nilfs_attach_checkpoint(struct nilfs_sb_info *sbi, __u64 cno) 393 { 394 struct the_nilfs *nilfs = sbi->s_nilfs; 395 struct nilfs_checkpoint *raw_cp; 396 struct buffer_head *bh_cp; 397 int err; 398 399 down_write(&nilfs->ns_super_sem); 400 list_add(&sbi->s_list, &nilfs->ns_supers); 401 up_write(&nilfs->ns_super_sem); 402 403 sbi->s_ifile = nilfs_ifile_new(sbi, nilfs->ns_inode_size); 404 if (!sbi->s_ifile) 405 return -ENOMEM; 406 407 down_read(&nilfs->ns_segctor_sem); 408 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp, 409 &bh_cp); 410 up_read(&nilfs->ns_segctor_sem); 411 if (unlikely(err)) { 412 if (err == -ENOENT || err == -EINVAL) { 413 printk(KERN_ERR 414 "NILFS: Invalid checkpoint " 415 "(checkpoint number=%llu)\n", 416 (unsigned long long)cno); 417 err = -EINVAL; 418 } 419 goto failed; 420 } 421 err = nilfs_read_inode_common(sbi->s_ifile, &raw_cp->cp_ifile_inode); 422 if (unlikely(err)) 423 goto failed_bh; 424 atomic_set(&sbi->s_inodes_count, le64_to_cpu(raw_cp->cp_inodes_count)); 425 atomic_set(&sbi->s_blocks_count, le64_to_cpu(raw_cp->cp_blocks_count)); 426 427 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 428 return 0; 429 430 failed_bh: 431 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 432 failed: 433 nilfs_mdt_destroy(sbi->s_ifile); 434 sbi->s_ifile = NULL; 435 436 down_write(&nilfs->ns_super_sem); 437 list_del_init(&sbi->s_list); 438 up_write(&nilfs->ns_super_sem); 439 440 return err; 441 } 442 443 void nilfs_detach_checkpoint(struct nilfs_sb_info *sbi) 444 { 445 struct the_nilfs *nilfs = sbi->s_nilfs; 446 447 nilfs_mdt_destroy(sbi->s_ifile); 448 sbi->s_ifile = NULL; 449 down_write(&nilfs->ns_super_sem); 450 list_del_init(&sbi->s_list); 451 up_write(&nilfs->ns_super_sem); 452 } 453 454 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 455 { 456 struct super_block *sb = dentry->d_sb; 457 struct nilfs_sb_info *sbi = NILFS_SB(sb); 458 struct the_nilfs *nilfs = sbi->s_nilfs; 459 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 460 unsigned long long blocks; 461 unsigned long overhead; 462 unsigned long nrsvblocks; 463 sector_t nfreeblocks; 464 int err; 465 466 /* 467 * Compute all of the segment blocks 468 * 469 * The blocks before first segment and after last segment 470 * are excluded. 471 */ 472 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments 473 - nilfs->ns_first_data_block; 474 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment; 475 476 /* 477 * Compute the overhead 478 * 479 * When distributing meta data blocks outside segment structure, 480 * We must count them as the overhead. 481 */ 482 overhead = 0; 483 484 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 485 if (unlikely(err)) 486 return err; 487 488 buf->f_type = NILFS_SUPER_MAGIC; 489 buf->f_bsize = sb->s_blocksize; 490 buf->f_blocks = blocks - overhead; 491 buf->f_bfree = nfreeblocks; 492 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? 493 (buf->f_bfree - nrsvblocks) : 0; 494 buf->f_files = atomic_read(&sbi->s_inodes_count); 495 buf->f_ffree = 0; /* nilfs_count_free_inodes(sb); */ 496 buf->f_namelen = NILFS_NAME_LEN; 497 buf->f_fsid.val[0] = (u32)id; 498 buf->f_fsid.val[1] = (u32)(id >> 32); 499 500 return 0; 501 } 502 503 static int nilfs_show_options(struct seq_file *seq, struct vfsmount *vfs) 504 { 505 struct super_block *sb = vfs->mnt_sb; 506 struct nilfs_sb_info *sbi = NILFS_SB(sb); 507 508 if (!nilfs_test_opt(sbi, BARRIER)) 509 seq_puts(seq, ",nobarrier"); 510 if (nilfs_test_opt(sbi, SNAPSHOT)) 511 seq_printf(seq, ",cp=%llu", 512 (unsigned long long int)sbi->s_snapshot_cno); 513 if (nilfs_test_opt(sbi, ERRORS_PANIC)) 514 seq_puts(seq, ",errors=panic"); 515 if (nilfs_test_opt(sbi, ERRORS_CONT)) 516 seq_puts(seq, ",errors=continue"); 517 if (nilfs_test_opt(sbi, STRICT_ORDER)) 518 seq_puts(seq, ",order=strict"); 519 if (nilfs_test_opt(sbi, NORECOVERY)) 520 seq_puts(seq, ",norecovery"); 521 if (nilfs_test_opt(sbi, DISCARD)) 522 seq_puts(seq, ",discard"); 523 524 return 0; 525 } 526 527 static const struct super_operations nilfs_sops = { 528 .alloc_inode = nilfs_alloc_inode, 529 .destroy_inode = nilfs_destroy_inode, 530 .dirty_inode = nilfs_dirty_inode, 531 /* .write_inode = nilfs_write_inode, */ 532 /* .put_inode = nilfs_put_inode, */ 533 /* .drop_inode = nilfs_drop_inode, */ 534 .evict_inode = nilfs_evict_inode, 535 .put_super = nilfs_put_super, 536 /* .write_super = nilfs_write_super, */ 537 .sync_fs = nilfs_sync_fs, 538 /* .write_super_lockfs */ 539 /* .unlockfs */ 540 .statfs = nilfs_statfs, 541 .remount_fs = nilfs_remount, 542 /* .umount_begin */ 543 .show_options = nilfs_show_options 544 }; 545 546 static struct inode * 547 nilfs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation) 548 { 549 struct inode *inode; 550 551 if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO && 552 ino != NILFS_SKETCH_INO) 553 return ERR_PTR(-ESTALE); 554 555 inode = nilfs_iget(sb, ino); 556 if (IS_ERR(inode)) 557 return ERR_CAST(inode); 558 if (generation && inode->i_generation != generation) { 559 iput(inode); 560 return ERR_PTR(-ESTALE); 561 } 562 563 return inode; 564 } 565 566 static struct dentry * 567 nilfs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, 568 int fh_type) 569 { 570 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 571 nilfs_nfs_get_inode); 572 } 573 574 static struct dentry * 575 nilfs_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, 576 int fh_type) 577 { 578 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 579 nilfs_nfs_get_inode); 580 } 581 582 static const struct export_operations nilfs_export_ops = { 583 .fh_to_dentry = nilfs_fh_to_dentry, 584 .fh_to_parent = nilfs_fh_to_parent, 585 .get_parent = nilfs_get_parent, 586 }; 587 588 enum { 589 Opt_err_cont, Opt_err_panic, Opt_err_ro, 590 Opt_barrier, Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery, 591 Opt_discard, Opt_nodiscard, Opt_err, 592 }; 593 594 static match_table_t tokens = { 595 {Opt_err_cont, "errors=continue"}, 596 {Opt_err_panic, "errors=panic"}, 597 {Opt_err_ro, "errors=remount-ro"}, 598 {Opt_barrier, "barrier"}, 599 {Opt_nobarrier, "nobarrier"}, 600 {Opt_snapshot, "cp=%u"}, 601 {Opt_order, "order=%s"}, 602 {Opt_norecovery, "norecovery"}, 603 {Opt_discard, "discard"}, 604 {Opt_nodiscard, "nodiscard"}, 605 {Opt_err, NULL} 606 }; 607 608 static int parse_options(char *options, struct super_block *sb, int is_remount) 609 { 610 struct nilfs_sb_info *sbi = NILFS_SB(sb); 611 char *p; 612 substring_t args[MAX_OPT_ARGS]; 613 int option; 614 615 if (!options) 616 return 1; 617 618 while ((p = strsep(&options, ",")) != NULL) { 619 int token; 620 if (!*p) 621 continue; 622 623 token = match_token(p, tokens, args); 624 switch (token) { 625 case Opt_barrier: 626 nilfs_set_opt(sbi, BARRIER); 627 break; 628 case Opt_nobarrier: 629 nilfs_clear_opt(sbi, BARRIER); 630 break; 631 case Opt_order: 632 if (strcmp(args[0].from, "relaxed") == 0) 633 /* Ordered data semantics */ 634 nilfs_clear_opt(sbi, STRICT_ORDER); 635 else if (strcmp(args[0].from, "strict") == 0) 636 /* Strict in-order semantics */ 637 nilfs_set_opt(sbi, STRICT_ORDER); 638 else 639 return 0; 640 break; 641 case Opt_err_panic: 642 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_PANIC); 643 break; 644 case Opt_err_ro: 645 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_RO); 646 break; 647 case Opt_err_cont: 648 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_CONT); 649 break; 650 case Opt_snapshot: 651 if (match_int(&args[0], &option) || option <= 0) 652 return 0; 653 if (is_remount) { 654 if (!nilfs_test_opt(sbi, SNAPSHOT)) { 655 printk(KERN_ERR 656 "NILFS: cannot change regular " 657 "mount to snapshot.\n"); 658 return 0; 659 } else if (option != sbi->s_snapshot_cno) { 660 printk(KERN_ERR 661 "NILFS: cannot remount to a " 662 "different snapshot.\n"); 663 return 0; 664 } 665 break; 666 } 667 if (!(sb->s_flags & MS_RDONLY)) { 668 printk(KERN_ERR "NILFS: cannot mount snapshot " 669 "read/write. A read-only option is " 670 "required.\n"); 671 return 0; 672 } 673 sbi->s_snapshot_cno = option; 674 nilfs_set_opt(sbi, SNAPSHOT); 675 break; 676 case Opt_norecovery: 677 nilfs_set_opt(sbi, NORECOVERY); 678 break; 679 case Opt_discard: 680 nilfs_set_opt(sbi, DISCARD); 681 break; 682 case Opt_nodiscard: 683 nilfs_clear_opt(sbi, DISCARD); 684 break; 685 default: 686 printk(KERN_ERR 687 "NILFS: Unrecognized mount option \"%s\"\n", p); 688 return 0; 689 } 690 } 691 return 1; 692 } 693 694 static inline void 695 nilfs_set_default_options(struct nilfs_sb_info *sbi, 696 struct nilfs_super_block *sbp) 697 { 698 sbi->s_mount_opt = 699 NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER; 700 } 701 702 static int nilfs_setup_super(struct nilfs_sb_info *sbi) 703 { 704 struct the_nilfs *nilfs = sbi->s_nilfs; 705 struct nilfs_super_block **sbp; 706 int max_mnt_count; 707 int mnt_count; 708 709 /* nilfs->ns_sem must be locked by the caller. */ 710 sbp = nilfs_prepare_super(sbi, 0); 711 if (!sbp) 712 return -EIO; 713 714 max_mnt_count = le16_to_cpu(sbp[0]->s_max_mnt_count); 715 mnt_count = le16_to_cpu(sbp[0]->s_mnt_count); 716 717 if (nilfs->ns_mount_state & NILFS_ERROR_FS) { 718 printk(KERN_WARNING 719 "NILFS warning: mounting fs with errors\n"); 720 #if 0 721 } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) { 722 printk(KERN_WARNING 723 "NILFS warning: maximal mount count reached\n"); 724 #endif 725 } 726 if (!max_mnt_count) 727 sbp[0]->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT); 728 729 sbp[0]->s_mnt_count = cpu_to_le16(mnt_count + 1); 730 sbp[0]->s_state = 731 cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & ~NILFS_VALID_FS); 732 sbp[0]->s_mtime = cpu_to_le64(get_seconds()); 733 /* synchronize sbp[1] with sbp[0] */ 734 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 735 return nilfs_commit_super(sbi, NILFS_SB_COMMIT_ALL); 736 } 737 738 struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb, 739 u64 pos, int blocksize, 740 struct buffer_head **pbh) 741 { 742 unsigned long long sb_index = pos; 743 unsigned long offset; 744 745 offset = do_div(sb_index, blocksize); 746 *pbh = sb_bread(sb, sb_index); 747 if (!*pbh) 748 return NULL; 749 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset); 750 } 751 752 int nilfs_store_magic_and_option(struct super_block *sb, 753 struct nilfs_super_block *sbp, 754 char *data) 755 { 756 struct nilfs_sb_info *sbi = NILFS_SB(sb); 757 758 sb->s_magic = le16_to_cpu(sbp->s_magic); 759 760 /* FS independent flags */ 761 #ifdef NILFS_ATIME_DISABLE 762 sb->s_flags |= MS_NOATIME; 763 #endif 764 765 nilfs_set_default_options(sbi, sbp); 766 767 sbi->s_resuid = le16_to_cpu(sbp->s_def_resuid); 768 sbi->s_resgid = le16_to_cpu(sbp->s_def_resgid); 769 sbi->s_interval = le32_to_cpu(sbp->s_c_interval); 770 sbi->s_watermark = le32_to_cpu(sbp->s_c_block_max); 771 772 return !parse_options(data, sb, 0) ? -EINVAL : 0 ; 773 } 774 775 int nilfs_check_feature_compatibility(struct super_block *sb, 776 struct nilfs_super_block *sbp) 777 { 778 __u64 features; 779 780 features = le64_to_cpu(sbp->s_feature_incompat) & 781 ~NILFS_FEATURE_INCOMPAT_SUPP; 782 if (features) { 783 printk(KERN_ERR "NILFS: couldn't mount because of unsupported " 784 "optional features (%llx)\n", 785 (unsigned long long)features); 786 return -EINVAL; 787 } 788 features = le64_to_cpu(sbp->s_feature_compat_ro) & 789 ~NILFS_FEATURE_COMPAT_RO_SUPP; 790 if (!(sb->s_flags & MS_RDONLY) && features) { 791 printk(KERN_ERR "NILFS: couldn't mount RDWR because of " 792 "unsupported optional features (%llx)\n", 793 (unsigned long long)features); 794 return -EINVAL; 795 } 796 return 0; 797 } 798 799 /** 800 * nilfs_fill_super() - initialize a super block instance 801 * @sb: super_block 802 * @data: mount options 803 * @silent: silent mode flag 804 * @nilfs: the_nilfs struct 805 * 806 * This function is called exclusively by nilfs->ns_mount_mutex. 807 * So, the recovery process is protected from other simultaneous mounts. 808 */ 809 static int 810 nilfs_fill_super(struct super_block *sb, void *data, int silent, 811 struct the_nilfs *nilfs) 812 { 813 struct nilfs_sb_info *sbi; 814 struct inode *root; 815 __u64 cno; 816 int err; 817 818 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); 819 if (!sbi) 820 return -ENOMEM; 821 822 sb->s_fs_info = sbi; 823 824 get_nilfs(nilfs); 825 sbi->s_nilfs = nilfs; 826 sbi->s_super = sb; 827 atomic_set(&sbi->s_count, 1); 828 829 err = init_nilfs(nilfs, sbi, (char *)data); 830 if (err) 831 goto failed_sbi; 832 833 spin_lock_init(&sbi->s_inode_lock); 834 INIT_LIST_HEAD(&sbi->s_dirty_files); 835 INIT_LIST_HEAD(&sbi->s_list); 836 837 /* 838 * Following initialization is overlapped because 839 * nilfs_sb_info structure has been cleared at the beginning. 840 * But we reserve them to keep our interest and make ready 841 * for the future change. 842 */ 843 get_random_bytes(&sbi->s_next_generation, 844 sizeof(sbi->s_next_generation)); 845 spin_lock_init(&sbi->s_next_gen_lock); 846 847 sb->s_op = &nilfs_sops; 848 sb->s_export_op = &nilfs_export_ops; 849 sb->s_root = NULL; 850 sb->s_time_gran = 1; 851 sb->s_bdi = nilfs->ns_bdi; 852 853 err = load_nilfs(nilfs, sbi); 854 if (err) 855 goto failed_sbi; 856 857 cno = nilfs_last_cno(nilfs); 858 859 if (sb->s_flags & MS_RDONLY) { 860 if (nilfs_test_opt(sbi, SNAPSHOT)) { 861 down_read(&nilfs->ns_segctor_sem); 862 err = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, 863 sbi->s_snapshot_cno); 864 up_read(&nilfs->ns_segctor_sem); 865 if (err < 0) { 866 if (err == -ENOENT) 867 err = -EINVAL; 868 goto failed_sbi; 869 } 870 if (!err) { 871 printk(KERN_ERR 872 "NILFS: The specified checkpoint is " 873 "not a snapshot " 874 "(checkpoint number=%llu).\n", 875 (unsigned long long)sbi->s_snapshot_cno); 876 err = -EINVAL; 877 goto failed_sbi; 878 } 879 cno = sbi->s_snapshot_cno; 880 } 881 } 882 883 err = nilfs_attach_checkpoint(sbi, cno); 884 if (err) { 885 printk(KERN_ERR "NILFS: error loading a checkpoint" 886 " (checkpoint number=%llu).\n", (unsigned long long)cno); 887 goto failed_sbi; 888 } 889 890 if (!(sb->s_flags & MS_RDONLY)) { 891 err = nilfs_attach_segment_constructor(sbi); 892 if (err) 893 goto failed_checkpoint; 894 } 895 896 root = nilfs_iget(sb, NILFS_ROOT_INO); 897 if (IS_ERR(root)) { 898 printk(KERN_ERR "NILFS: get root inode failed\n"); 899 err = PTR_ERR(root); 900 goto failed_segctor; 901 } 902 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { 903 iput(root); 904 printk(KERN_ERR "NILFS: corrupt root inode.\n"); 905 err = -EINVAL; 906 goto failed_segctor; 907 } 908 sb->s_root = d_alloc_root(root); 909 if (!sb->s_root) { 910 iput(root); 911 printk(KERN_ERR "NILFS: get root dentry failed\n"); 912 err = -ENOMEM; 913 goto failed_segctor; 914 } 915 916 if (!(sb->s_flags & MS_RDONLY)) { 917 down_write(&nilfs->ns_sem); 918 nilfs_setup_super(sbi); 919 up_write(&nilfs->ns_sem); 920 } 921 922 down_write(&nilfs->ns_super_sem); 923 if (!nilfs_test_opt(sbi, SNAPSHOT)) 924 nilfs->ns_current = sbi; 925 up_write(&nilfs->ns_super_sem); 926 927 return 0; 928 929 failed_segctor: 930 nilfs_detach_segment_constructor(sbi); 931 932 failed_checkpoint: 933 nilfs_detach_checkpoint(sbi); 934 935 failed_sbi: 936 put_nilfs(nilfs); 937 sb->s_fs_info = NULL; 938 nilfs_put_sbinfo(sbi); 939 return err; 940 } 941 942 static int nilfs_remount(struct super_block *sb, int *flags, char *data) 943 { 944 struct nilfs_sb_info *sbi = NILFS_SB(sb); 945 struct the_nilfs *nilfs = sbi->s_nilfs; 946 unsigned long old_sb_flags; 947 struct nilfs_mount_options old_opts; 948 int was_snapshot, err; 949 950 lock_kernel(); 951 952 down_write(&nilfs->ns_super_sem); 953 old_sb_flags = sb->s_flags; 954 old_opts.mount_opt = sbi->s_mount_opt; 955 old_opts.snapshot_cno = sbi->s_snapshot_cno; 956 was_snapshot = nilfs_test_opt(sbi, SNAPSHOT); 957 958 if (!parse_options(data, sb, 1)) { 959 err = -EINVAL; 960 goto restore_opts; 961 } 962 sb->s_flags = (sb->s_flags & ~MS_POSIXACL); 963 964 err = -EINVAL; 965 if (was_snapshot && !(*flags & MS_RDONLY)) { 966 printk(KERN_ERR "NILFS (device %s): cannot remount snapshot " 967 "read/write.\n", sb->s_id); 968 goto restore_opts; 969 } 970 971 if (!nilfs_valid_fs(nilfs)) { 972 printk(KERN_WARNING "NILFS (device %s): couldn't " 973 "remount because the filesystem is in an " 974 "incomplete recovery state.\n", sb->s_id); 975 goto restore_opts; 976 } 977 978 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 979 goto out; 980 if (*flags & MS_RDONLY) { 981 /* Shutting down the segment constructor */ 982 nilfs_detach_segment_constructor(sbi); 983 sb->s_flags |= MS_RDONLY; 984 985 /* 986 * Remounting a valid RW partition RDONLY, so set 987 * the RDONLY flag and then mark the partition as valid again. 988 */ 989 down_write(&nilfs->ns_sem); 990 nilfs_cleanup_super(sbi); 991 up_write(&nilfs->ns_sem); 992 } else { 993 __u64 features; 994 995 /* 996 * Mounting a RDONLY partition read-write, so reread and 997 * store the current valid flag. (It may have been changed 998 * by fsck since we originally mounted the partition.) 999 */ 1000 down_read(&nilfs->ns_sem); 1001 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & 1002 ~NILFS_FEATURE_COMPAT_RO_SUPP; 1003 up_read(&nilfs->ns_sem); 1004 if (features) { 1005 printk(KERN_WARNING "NILFS (device %s): couldn't " 1006 "remount RDWR because of unsupported optional " 1007 "features (%llx)\n", 1008 sb->s_id, (unsigned long long)features); 1009 err = -EROFS; 1010 goto restore_opts; 1011 } 1012 1013 sb->s_flags &= ~MS_RDONLY; 1014 1015 err = nilfs_attach_segment_constructor(sbi); 1016 if (err) 1017 goto restore_opts; 1018 1019 down_write(&nilfs->ns_sem); 1020 nilfs_setup_super(sbi); 1021 up_write(&nilfs->ns_sem); 1022 } 1023 out: 1024 up_write(&nilfs->ns_super_sem); 1025 unlock_kernel(); 1026 return 0; 1027 1028 restore_opts: 1029 sb->s_flags = old_sb_flags; 1030 sbi->s_mount_opt = old_opts.mount_opt; 1031 sbi->s_snapshot_cno = old_opts.snapshot_cno; 1032 up_write(&nilfs->ns_super_sem); 1033 unlock_kernel(); 1034 return err; 1035 } 1036 1037 struct nilfs_super_data { 1038 struct block_device *bdev; 1039 struct nilfs_sb_info *sbi; 1040 __u64 cno; 1041 int flags; 1042 }; 1043 1044 /** 1045 * nilfs_identify - pre-read mount options needed to identify mount instance 1046 * @data: mount options 1047 * @sd: nilfs_super_data 1048 */ 1049 static int nilfs_identify(char *data, struct nilfs_super_data *sd) 1050 { 1051 char *p, *options = data; 1052 substring_t args[MAX_OPT_ARGS]; 1053 int option, token; 1054 int ret = 0; 1055 1056 do { 1057 p = strsep(&options, ","); 1058 if (p != NULL && *p) { 1059 token = match_token(p, tokens, args); 1060 if (token == Opt_snapshot) { 1061 if (!(sd->flags & MS_RDONLY)) 1062 ret++; 1063 else { 1064 ret = match_int(&args[0], &option); 1065 if (!ret) { 1066 if (option > 0) 1067 sd->cno = option; 1068 else 1069 ret++; 1070 } 1071 } 1072 } 1073 if (ret) 1074 printk(KERN_ERR 1075 "NILFS: invalid mount option: %s\n", p); 1076 } 1077 if (!options) 1078 break; 1079 BUG_ON(options == data); 1080 *(options - 1) = ','; 1081 } while (!ret); 1082 return ret; 1083 } 1084 1085 static int nilfs_set_bdev_super(struct super_block *s, void *data) 1086 { 1087 struct nilfs_super_data *sd = data; 1088 1089 s->s_bdev = sd->bdev; 1090 s->s_dev = s->s_bdev->bd_dev; 1091 return 0; 1092 } 1093 1094 static int nilfs_test_bdev_super(struct super_block *s, void *data) 1095 { 1096 struct nilfs_super_data *sd = data; 1097 1098 return sd->sbi && s->s_fs_info == (void *)sd->sbi; 1099 } 1100 1101 static int 1102 nilfs_get_sb(struct file_system_type *fs_type, int flags, 1103 const char *dev_name, void *data, struct vfsmount *mnt) 1104 { 1105 struct nilfs_super_data sd; 1106 struct super_block *s; 1107 fmode_t mode = FMODE_READ; 1108 struct the_nilfs *nilfs; 1109 int err, need_to_close = 1; 1110 1111 if (!(flags & MS_RDONLY)) 1112 mode |= FMODE_WRITE; 1113 1114 sd.bdev = open_bdev_exclusive(dev_name, mode, fs_type); 1115 if (IS_ERR(sd.bdev)) 1116 return PTR_ERR(sd.bdev); 1117 1118 /* 1119 * To get mount instance using sget() vfs-routine, NILFS needs 1120 * much more information than normal filesystems to identify mount 1121 * instance. For snapshot mounts, not only a mount type (ro-mount 1122 * or rw-mount) but also a checkpoint number is required. 1123 */ 1124 sd.cno = 0; 1125 sd.flags = flags; 1126 if (nilfs_identify((char *)data, &sd)) { 1127 err = -EINVAL; 1128 goto failed; 1129 } 1130 1131 nilfs = find_or_create_nilfs(sd.bdev); 1132 if (!nilfs) { 1133 err = -ENOMEM; 1134 goto failed; 1135 } 1136 1137 mutex_lock(&nilfs->ns_mount_mutex); 1138 1139 if (!sd.cno) { 1140 /* 1141 * Check if an exclusive mount exists or not. 1142 * Snapshot mounts coexist with a current mount 1143 * (i.e. rw-mount or ro-mount), whereas rw-mount and 1144 * ro-mount are mutually exclusive. 1145 */ 1146 down_read(&nilfs->ns_super_sem); 1147 if (nilfs->ns_current && 1148 ((nilfs->ns_current->s_super->s_flags ^ flags) 1149 & MS_RDONLY)) { 1150 up_read(&nilfs->ns_super_sem); 1151 err = -EBUSY; 1152 goto failed_unlock; 1153 } 1154 up_read(&nilfs->ns_super_sem); 1155 } 1156 1157 /* 1158 * Find existing nilfs_sb_info struct 1159 */ 1160 sd.sbi = nilfs_find_sbinfo(nilfs, !(flags & MS_RDONLY), sd.cno); 1161 1162 /* 1163 * Get super block instance holding the nilfs_sb_info struct. 1164 * A new instance is allocated if no existing mount is present or 1165 * existing instance has been unmounted. 1166 */ 1167 s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd); 1168 if (sd.sbi) 1169 nilfs_put_sbinfo(sd.sbi); 1170 1171 if (IS_ERR(s)) { 1172 err = PTR_ERR(s); 1173 goto failed_unlock; 1174 } 1175 1176 if (!s->s_root) { 1177 char b[BDEVNAME_SIZE]; 1178 1179 /* New superblock instance created */ 1180 s->s_flags = flags; 1181 s->s_mode = mode; 1182 strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id)); 1183 sb_set_blocksize(s, block_size(sd.bdev)); 1184 1185 err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0, 1186 nilfs); 1187 if (err) 1188 goto cancel_new; 1189 1190 s->s_flags |= MS_ACTIVE; 1191 need_to_close = 0; 1192 } 1193 1194 mutex_unlock(&nilfs->ns_mount_mutex); 1195 put_nilfs(nilfs); 1196 if (need_to_close) 1197 close_bdev_exclusive(sd.bdev, mode); 1198 simple_set_mnt(mnt, s); 1199 return 0; 1200 1201 failed_unlock: 1202 mutex_unlock(&nilfs->ns_mount_mutex); 1203 put_nilfs(nilfs); 1204 failed: 1205 close_bdev_exclusive(sd.bdev, mode); 1206 1207 return err; 1208 1209 cancel_new: 1210 /* Abandoning the newly allocated superblock */ 1211 mutex_unlock(&nilfs->ns_mount_mutex); 1212 put_nilfs(nilfs); 1213 deactivate_locked_super(s); 1214 /* 1215 * deactivate_locked_super() invokes close_bdev_exclusive(). 1216 * We must finish all post-cleaning before this call; 1217 * put_nilfs() needs the block device. 1218 */ 1219 return err; 1220 } 1221 1222 struct file_system_type nilfs_fs_type = { 1223 .owner = THIS_MODULE, 1224 .name = "nilfs2", 1225 .get_sb = nilfs_get_sb, 1226 .kill_sb = kill_block_super, 1227 .fs_flags = FS_REQUIRES_DEV, 1228 }; 1229 1230 static void nilfs_inode_init_once(void *obj) 1231 { 1232 struct nilfs_inode_info *ii = obj; 1233 1234 INIT_LIST_HEAD(&ii->i_dirty); 1235 #ifdef CONFIG_NILFS_XATTR 1236 init_rwsem(&ii->xattr_sem); 1237 #endif 1238 nilfs_btnode_cache_init_once(&ii->i_btnode_cache); 1239 ii->i_bmap = &ii->i_bmap_data; 1240 inode_init_once(&ii->vfs_inode); 1241 } 1242 1243 static void nilfs_segbuf_init_once(void *obj) 1244 { 1245 memset(obj, 0, sizeof(struct nilfs_segment_buffer)); 1246 } 1247 1248 static void nilfs_destroy_cachep(void) 1249 { 1250 if (nilfs_inode_cachep) 1251 kmem_cache_destroy(nilfs_inode_cachep); 1252 if (nilfs_transaction_cachep) 1253 kmem_cache_destroy(nilfs_transaction_cachep); 1254 if (nilfs_segbuf_cachep) 1255 kmem_cache_destroy(nilfs_segbuf_cachep); 1256 if (nilfs_btree_path_cache) 1257 kmem_cache_destroy(nilfs_btree_path_cache); 1258 } 1259 1260 static int __init nilfs_init_cachep(void) 1261 { 1262 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", 1263 sizeof(struct nilfs_inode_info), 0, 1264 SLAB_RECLAIM_ACCOUNT, nilfs_inode_init_once); 1265 if (!nilfs_inode_cachep) 1266 goto fail; 1267 1268 nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache", 1269 sizeof(struct nilfs_transaction_info), 0, 1270 SLAB_RECLAIM_ACCOUNT, NULL); 1271 if (!nilfs_transaction_cachep) 1272 goto fail; 1273 1274 nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache", 1275 sizeof(struct nilfs_segment_buffer), 0, 1276 SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once); 1277 if (!nilfs_segbuf_cachep) 1278 goto fail; 1279 1280 nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache", 1281 sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX, 1282 0, 0, NULL); 1283 if (!nilfs_btree_path_cache) 1284 goto fail; 1285 1286 return 0; 1287 1288 fail: 1289 nilfs_destroy_cachep(); 1290 return -ENOMEM; 1291 } 1292 1293 static int __init init_nilfs_fs(void) 1294 { 1295 int err; 1296 1297 err = nilfs_init_cachep(); 1298 if (err) 1299 goto fail; 1300 1301 err = register_filesystem(&nilfs_fs_type); 1302 if (err) 1303 goto free_cachep; 1304 1305 printk(KERN_INFO "NILFS version 2 loaded\n"); 1306 return 0; 1307 1308 free_cachep: 1309 nilfs_destroy_cachep(); 1310 fail: 1311 return err; 1312 } 1313 1314 static void __exit exit_nilfs_fs(void) 1315 { 1316 nilfs_destroy_cachep(); 1317 unregister_filesystem(&nilfs_fs_type); 1318 } 1319 1320 module_init(init_nilfs_fs) 1321 module_exit(exit_nilfs_fs) 1322