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 179 retry: 180 set_buffer_dirty(nilfs->ns_sbh[0]); 181 182 if (nilfs_test_opt(sbi, BARRIER)) { 183 err = __sync_dirty_buffer(nilfs->ns_sbh[0], 184 WRITE_SYNC | WRITE_BARRIER); 185 if (err == -EOPNOTSUPP) { 186 nilfs_warning(sbi->s_super, __func__, 187 "barrier-based sync failed. " 188 "disabling barriers\n"); 189 nilfs_clear_opt(sbi, BARRIER); 190 goto retry; 191 } 192 } else { 193 err = sync_dirty_buffer(nilfs->ns_sbh[0]); 194 } 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 err = -ENOMEM; 404 sbi->s_ifile = nilfs_ifile_new(sbi, nilfs->ns_inode_size); 405 if (!sbi->s_ifile) 406 goto delist; 407 408 down_read(&nilfs->ns_segctor_sem); 409 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp, 410 &bh_cp); 411 up_read(&nilfs->ns_segctor_sem); 412 if (unlikely(err)) { 413 if (err == -ENOENT || err == -EINVAL) { 414 printk(KERN_ERR 415 "NILFS: Invalid checkpoint " 416 "(checkpoint number=%llu)\n", 417 (unsigned long long)cno); 418 err = -EINVAL; 419 } 420 goto failed; 421 } 422 err = nilfs_read_inode_common(sbi->s_ifile, &raw_cp->cp_ifile_inode); 423 if (unlikely(err)) 424 goto failed_bh; 425 atomic_set(&sbi->s_inodes_count, le64_to_cpu(raw_cp->cp_inodes_count)); 426 atomic_set(&sbi->s_blocks_count, le64_to_cpu(raw_cp->cp_blocks_count)); 427 428 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 429 return 0; 430 431 failed_bh: 432 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 433 failed: 434 nilfs_mdt_destroy(sbi->s_ifile); 435 sbi->s_ifile = NULL; 436 437 delist: 438 down_write(&nilfs->ns_super_sem); 439 list_del_init(&sbi->s_list); 440 up_write(&nilfs->ns_super_sem); 441 442 return err; 443 } 444 445 void nilfs_detach_checkpoint(struct nilfs_sb_info *sbi) 446 { 447 struct the_nilfs *nilfs = sbi->s_nilfs; 448 449 nilfs_mdt_destroy(sbi->s_ifile); 450 sbi->s_ifile = NULL; 451 down_write(&nilfs->ns_super_sem); 452 list_del_init(&sbi->s_list); 453 up_write(&nilfs->ns_super_sem); 454 } 455 456 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 457 { 458 struct super_block *sb = dentry->d_sb; 459 struct nilfs_sb_info *sbi = NILFS_SB(sb); 460 struct the_nilfs *nilfs = sbi->s_nilfs; 461 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 462 unsigned long long blocks; 463 unsigned long overhead; 464 unsigned long nrsvblocks; 465 sector_t nfreeblocks; 466 int err; 467 468 /* 469 * Compute all of the segment blocks 470 * 471 * The blocks before first segment and after last segment 472 * are excluded. 473 */ 474 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments 475 - nilfs->ns_first_data_block; 476 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment; 477 478 /* 479 * Compute the overhead 480 * 481 * When distributing meta data blocks outside segment structure, 482 * We must count them as the overhead. 483 */ 484 overhead = 0; 485 486 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 487 if (unlikely(err)) 488 return err; 489 490 buf->f_type = NILFS_SUPER_MAGIC; 491 buf->f_bsize = sb->s_blocksize; 492 buf->f_blocks = blocks - overhead; 493 buf->f_bfree = nfreeblocks; 494 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? 495 (buf->f_bfree - nrsvblocks) : 0; 496 buf->f_files = atomic_read(&sbi->s_inodes_count); 497 buf->f_ffree = 0; /* nilfs_count_free_inodes(sb); */ 498 buf->f_namelen = NILFS_NAME_LEN; 499 buf->f_fsid.val[0] = (u32)id; 500 buf->f_fsid.val[1] = (u32)(id >> 32); 501 502 return 0; 503 } 504 505 static int nilfs_show_options(struct seq_file *seq, struct vfsmount *vfs) 506 { 507 struct super_block *sb = vfs->mnt_sb; 508 struct nilfs_sb_info *sbi = NILFS_SB(sb); 509 510 if (!nilfs_test_opt(sbi, BARRIER)) 511 seq_puts(seq, ",nobarrier"); 512 if (nilfs_test_opt(sbi, SNAPSHOT)) 513 seq_printf(seq, ",cp=%llu", 514 (unsigned long long int)sbi->s_snapshot_cno); 515 if (nilfs_test_opt(sbi, ERRORS_PANIC)) 516 seq_puts(seq, ",errors=panic"); 517 if (nilfs_test_opt(sbi, ERRORS_CONT)) 518 seq_puts(seq, ",errors=continue"); 519 if (nilfs_test_opt(sbi, STRICT_ORDER)) 520 seq_puts(seq, ",order=strict"); 521 if (nilfs_test_opt(sbi, NORECOVERY)) 522 seq_puts(seq, ",norecovery"); 523 if (nilfs_test_opt(sbi, DISCARD)) 524 seq_puts(seq, ",discard"); 525 526 return 0; 527 } 528 529 static const struct super_operations nilfs_sops = { 530 .alloc_inode = nilfs_alloc_inode, 531 .destroy_inode = nilfs_destroy_inode, 532 .dirty_inode = nilfs_dirty_inode, 533 /* .write_inode = nilfs_write_inode, */ 534 /* .put_inode = nilfs_put_inode, */ 535 /* .drop_inode = nilfs_drop_inode, */ 536 .evict_inode = nilfs_evict_inode, 537 .put_super = nilfs_put_super, 538 /* .write_super = nilfs_write_super, */ 539 .sync_fs = nilfs_sync_fs, 540 /* .write_super_lockfs */ 541 /* .unlockfs */ 542 .statfs = nilfs_statfs, 543 .remount_fs = nilfs_remount, 544 /* .umount_begin */ 545 .show_options = nilfs_show_options 546 }; 547 548 static struct inode * 549 nilfs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation) 550 { 551 struct inode *inode; 552 553 if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO && 554 ino != NILFS_SKETCH_INO) 555 return ERR_PTR(-ESTALE); 556 557 inode = nilfs_iget(sb, ino); 558 if (IS_ERR(inode)) 559 return ERR_CAST(inode); 560 if (generation && inode->i_generation != generation) { 561 iput(inode); 562 return ERR_PTR(-ESTALE); 563 } 564 565 return inode; 566 } 567 568 static struct dentry * 569 nilfs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, 570 int fh_type) 571 { 572 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 573 nilfs_nfs_get_inode); 574 } 575 576 static struct dentry * 577 nilfs_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, 578 int fh_type) 579 { 580 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 581 nilfs_nfs_get_inode); 582 } 583 584 static const struct export_operations nilfs_export_ops = { 585 .fh_to_dentry = nilfs_fh_to_dentry, 586 .fh_to_parent = nilfs_fh_to_parent, 587 .get_parent = nilfs_get_parent, 588 }; 589 590 enum { 591 Opt_err_cont, Opt_err_panic, Opt_err_ro, 592 Opt_barrier, Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery, 593 Opt_discard, Opt_nodiscard, Opt_err, 594 }; 595 596 static match_table_t tokens = { 597 {Opt_err_cont, "errors=continue"}, 598 {Opt_err_panic, "errors=panic"}, 599 {Opt_err_ro, "errors=remount-ro"}, 600 {Opt_barrier, "barrier"}, 601 {Opt_nobarrier, "nobarrier"}, 602 {Opt_snapshot, "cp=%u"}, 603 {Opt_order, "order=%s"}, 604 {Opt_norecovery, "norecovery"}, 605 {Opt_discard, "discard"}, 606 {Opt_nodiscard, "nodiscard"}, 607 {Opt_err, NULL} 608 }; 609 610 static int parse_options(char *options, struct super_block *sb, int is_remount) 611 { 612 struct nilfs_sb_info *sbi = NILFS_SB(sb); 613 char *p; 614 substring_t args[MAX_OPT_ARGS]; 615 int option; 616 617 if (!options) 618 return 1; 619 620 while ((p = strsep(&options, ",")) != NULL) { 621 int token; 622 if (!*p) 623 continue; 624 625 token = match_token(p, tokens, args); 626 switch (token) { 627 case Opt_barrier: 628 nilfs_set_opt(sbi, BARRIER); 629 break; 630 case Opt_nobarrier: 631 nilfs_clear_opt(sbi, BARRIER); 632 break; 633 case Opt_order: 634 if (strcmp(args[0].from, "relaxed") == 0) 635 /* Ordered data semantics */ 636 nilfs_clear_opt(sbi, STRICT_ORDER); 637 else if (strcmp(args[0].from, "strict") == 0) 638 /* Strict in-order semantics */ 639 nilfs_set_opt(sbi, STRICT_ORDER); 640 else 641 return 0; 642 break; 643 case Opt_err_panic: 644 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_PANIC); 645 break; 646 case Opt_err_ro: 647 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_RO); 648 break; 649 case Opt_err_cont: 650 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_CONT); 651 break; 652 case Opt_snapshot: 653 if (match_int(&args[0], &option) || option <= 0) 654 return 0; 655 if (is_remount) { 656 if (!nilfs_test_opt(sbi, SNAPSHOT)) { 657 printk(KERN_ERR 658 "NILFS: cannot change regular " 659 "mount to snapshot.\n"); 660 return 0; 661 } else if (option != sbi->s_snapshot_cno) { 662 printk(KERN_ERR 663 "NILFS: cannot remount to a " 664 "different snapshot.\n"); 665 return 0; 666 } 667 break; 668 } 669 if (!(sb->s_flags & MS_RDONLY)) { 670 printk(KERN_ERR "NILFS: cannot mount snapshot " 671 "read/write. A read-only option is " 672 "required.\n"); 673 return 0; 674 } 675 sbi->s_snapshot_cno = option; 676 nilfs_set_opt(sbi, SNAPSHOT); 677 break; 678 case Opt_norecovery: 679 nilfs_set_opt(sbi, NORECOVERY); 680 break; 681 case Opt_discard: 682 nilfs_set_opt(sbi, DISCARD); 683 break; 684 case Opt_nodiscard: 685 nilfs_clear_opt(sbi, DISCARD); 686 break; 687 default: 688 printk(KERN_ERR 689 "NILFS: Unrecognized mount option \"%s\"\n", p); 690 return 0; 691 } 692 } 693 return 1; 694 } 695 696 static inline void 697 nilfs_set_default_options(struct nilfs_sb_info *sbi, 698 struct nilfs_super_block *sbp) 699 { 700 sbi->s_mount_opt = 701 NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER; 702 } 703 704 static int nilfs_setup_super(struct nilfs_sb_info *sbi) 705 { 706 struct the_nilfs *nilfs = sbi->s_nilfs; 707 struct nilfs_super_block **sbp; 708 int max_mnt_count; 709 int mnt_count; 710 711 /* nilfs->ns_sem must be locked by the caller. */ 712 sbp = nilfs_prepare_super(sbi, 0); 713 if (!sbp) 714 return -EIO; 715 716 max_mnt_count = le16_to_cpu(sbp[0]->s_max_mnt_count); 717 mnt_count = le16_to_cpu(sbp[0]->s_mnt_count); 718 719 if (nilfs->ns_mount_state & NILFS_ERROR_FS) { 720 printk(KERN_WARNING 721 "NILFS warning: mounting fs with errors\n"); 722 #if 0 723 } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) { 724 printk(KERN_WARNING 725 "NILFS warning: maximal mount count reached\n"); 726 #endif 727 } 728 if (!max_mnt_count) 729 sbp[0]->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT); 730 731 sbp[0]->s_mnt_count = cpu_to_le16(mnt_count + 1); 732 sbp[0]->s_state = 733 cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & ~NILFS_VALID_FS); 734 sbp[0]->s_mtime = cpu_to_le64(get_seconds()); 735 /* synchronize sbp[1] with sbp[0] */ 736 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 737 return nilfs_commit_super(sbi, NILFS_SB_COMMIT_ALL); 738 } 739 740 struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb, 741 u64 pos, int blocksize, 742 struct buffer_head **pbh) 743 { 744 unsigned long long sb_index = pos; 745 unsigned long offset; 746 747 offset = do_div(sb_index, blocksize); 748 *pbh = sb_bread(sb, sb_index); 749 if (!*pbh) 750 return NULL; 751 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset); 752 } 753 754 int nilfs_store_magic_and_option(struct super_block *sb, 755 struct nilfs_super_block *sbp, 756 char *data) 757 { 758 struct nilfs_sb_info *sbi = NILFS_SB(sb); 759 760 sb->s_magic = le16_to_cpu(sbp->s_magic); 761 762 /* FS independent flags */ 763 #ifdef NILFS_ATIME_DISABLE 764 sb->s_flags |= MS_NOATIME; 765 #endif 766 767 nilfs_set_default_options(sbi, sbp); 768 769 sbi->s_resuid = le16_to_cpu(sbp->s_def_resuid); 770 sbi->s_resgid = le16_to_cpu(sbp->s_def_resgid); 771 sbi->s_interval = le32_to_cpu(sbp->s_c_interval); 772 sbi->s_watermark = le32_to_cpu(sbp->s_c_block_max); 773 774 return !parse_options(data, sb, 0) ? -EINVAL : 0 ; 775 } 776 777 int nilfs_check_feature_compatibility(struct super_block *sb, 778 struct nilfs_super_block *sbp) 779 { 780 __u64 features; 781 782 features = le64_to_cpu(sbp->s_feature_incompat) & 783 ~NILFS_FEATURE_INCOMPAT_SUPP; 784 if (features) { 785 printk(KERN_ERR "NILFS: couldn't mount because of unsupported " 786 "optional features (%llx)\n", 787 (unsigned long long)features); 788 return -EINVAL; 789 } 790 features = le64_to_cpu(sbp->s_feature_compat_ro) & 791 ~NILFS_FEATURE_COMPAT_RO_SUPP; 792 if (!(sb->s_flags & MS_RDONLY) && features) { 793 printk(KERN_ERR "NILFS: couldn't mount RDWR because of " 794 "unsupported optional features (%llx)\n", 795 (unsigned long long)features); 796 return -EINVAL; 797 } 798 return 0; 799 } 800 801 /** 802 * nilfs_fill_super() - initialize a super block instance 803 * @sb: super_block 804 * @data: mount options 805 * @silent: silent mode flag 806 * @nilfs: the_nilfs struct 807 * 808 * This function is called exclusively by nilfs->ns_mount_mutex. 809 * So, the recovery process is protected from other simultaneous mounts. 810 */ 811 static int 812 nilfs_fill_super(struct super_block *sb, void *data, int silent, 813 struct the_nilfs *nilfs) 814 { 815 struct nilfs_sb_info *sbi; 816 struct inode *root; 817 __u64 cno; 818 int err; 819 820 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); 821 if (!sbi) 822 return -ENOMEM; 823 824 sb->s_fs_info = sbi; 825 826 get_nilfs(nilfs); 827 sbi->s_nilfs = nilfs; 828 sbi->s_super = sb; 829 atomic_set(&sbi->s_count, 1); 830 831 err = init_nilfs(nilfs, sbi, (char *)data); 832 if (err) 833 goto failed_sbi; 834 835 spin_lock_init(&sbi->s_inode_lock); 836 INIT_LIST_HEAD(&sbi->s_dirty_files); 837 INIT_LIST_HEAD(&sbi->s_list); 838 839 /* 840 * Following initialization is overlapped because 841 * nilfs_sb_info structure has been cleared at the beginning. 842 * But we reserve them to keep our interest and make ready 843 * for the future change. 844 */ 845 get_random_bytes(&sbi->s_next_generation, 846 sizeof(sbi->s_next_generation)); 847 spin_lock_init(&sbi->s_next_gen_lock); 848 849 sb->s_op = &nilfs_sops; 850 sb->s_export_op = &nilfs_export_ops; 851 sb->s_root = NULL; 852 sb->s_time_gran = 1; 853 sb->s_bdi = nilfs->ns_bdi; 854 855 err = load_nilfs(nilfs, sbi); 856 if (err) 857 goto failed_sbi; 858 859 cno = nilfs_last_cno(nilfs); 860 861 if (sb->s_flags & MS_RDONLY) { 862 if (nilfs_test_opt(sbi, SNAPSHOT)) { 863 down_read(&nilfs->ns_segctor_sem); 864 err = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, 865 sbi->s_snapshot_cno); 866 up_read(&nilfs->ns_segctor_sem); 867 if (err < 0) { 868 if (err == -ENOENT) 869 err = -EINVAL; 870 goto failed_sbi; 871 } 872 if (!err) { 873 printk(KERN_ERR 874 "NILFS: The specified checkpoint is " 875 "not a snapshot " 876 "(checkpoint number=%llu).\n", 877 (unsigned long long)sbi->s_snapshot_cno); 878 err = -EINVAL; 879 goto failed_sbi; 880 } 881 cno = sbi->s_snapshot_cno; 882 } 883 } 884 885 err = nilfs_attach_checkpoint(sbi, cno); 886 if (err) { 887 printk(KERN_ERR "NILFS: error loading a checkpoint" 888 " (checkpoint number=%llu).\n", (unsigned long long)cno); 889 goto failed_sbi; 890 } 891 892 if (!(sb->s_flags & MS_RDONLY)) { 893 err = nilfs_attach_segment_constructor(sbi); 894 if (err) 895 goto failed_checkpoint; 896 } 897 898 root = nilfs_iget(sb, NILFS_ROOT_INO); 899 if (IS_ERR(root)) { 900 printk(KERN_ERR "NILFS: get root inode failed\n"); 901 err = PTR_ERR(root); 902 goto failed_segctor; 903 } 904 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { 905 iput(root); 906 printk(KERN_ERR "NILFS: corrupt root inode.\n"); 907 err = -EINVAL; 908 goto failed_segctor; 909 } 910 sb->s_root = d_alloc_root(root); 911 if (!sb->s_root) { 912 iput(root); 913 printk(KERN_ERR "NILFS: get root dentry failed\n"); 914 err = -ENOMEM; 915 goto failed_segctor; 916 } 917 918 if (!(sb->s_flags & MS_RDONLY)) { 919 down_write(&nilfs->ns_sem); 920 nilfs_setup_super(sbi); 921 up_write(&nilfs->ns_sem); 922 } 923 924 down_write(&nilfs->ns_super_sem); 925 if (!nilfs_test_opt(sbi, SNAPSHOT)) 926 nilfs->ns_current = sbi; 927 up_write(&nilfs->ns_super_sem); 928 929 return 0; 930 931 failed_segctor: 932 nilfs_detach_segment_constructor(sbi); 933 934 failed_checkpoint: 935 nilfs_detach_checkpoint(sbi); 936 937 failed_sbi: 938 put_nilfs(nilfs); 939 sb->s_fs_info = NULL; 940 nilfs_put_sbinfo(sbi); 941 return err; 942 } 943 944 static int nilfs_remount(struct super_block *sb, int *flags, char *data) 945 { 946 struct nilfs_sb_info *sbi = NILFS_SB(sb); 947 struct the_nilfs *nilfs = sbi->s_nilfs; 948 unsigned long old_sb_flags; 949 struct nilfs_mount_options old_opts; 950 int was_snapshot, err; 951 952 lock_kernel(); 953 954 down_write(&nilfs->ns_super_sem); 955 old_sb_flags = sb->s_flags; 956 old_opts.mount_opt = sbi->s_mount_opt; 957 old_opts.snapshot_cno = sbi->s_snapshot_cno; 958 was_snapshot = nilfs_test_opt(sbi, SNAPSHOT); 959 960 if (!parse_options(data, sb, 1)) { 961 err = -EINVAL; 962 goto restore_opts; 963 } 964 sb->s_flags = (sb->s_flags & ~MS_POSIXACL); 965 966 err = -EINVAL; 967 if (was_snapshot && !(*flags & MS_RDONLY)) { 968 printk(KERN_ERR "NILFS (device %s): cannot remount snapshot " 969 "read/write.\n", sb->s_id); 970 goto restore_opts; 971 } 972 973 if (!nilfs_valid_fs(nilfs)) { 974 printk(KERN_WARNING "NILFS (device %s): couldn't " 975 "remount because the filesystem is in an " 976 "incomplete recovery state.\n", sb->s_id); 977 goto restore_opts; 978 } 979 980 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 981 goto out; 982 if (*flags & MS_RDONLY) { 983 /* Shutting down the segment constructor */ 984 nilfs_detach_segment_constructor(sbi); 985 sb->s_flags |= MS_RDONLY; 986 987 /* 988 * Remounting a valid RW partition RDONLY, so set 989 * the RDONLY flag and then mark the partition as valid again. 990 */ 991 down_write(&nilfs->ns_sem); 992 nilfs_cleanup_super(sbi); 993 up_write(&nilfs->ns_sem); 994 } else { 995 __u64 features; 996 997 /* 998 * Mounting a RDONLY partition read-write, so reread and 999 * store the current valid flag. (It may have been changed 1000 * by fsck since we originally mounted the partition.) 1001 */ 1002 down_read(&nilfs->ns_sem); 1003 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & 1004 ~NILFS_FEATURE_COMPAT_RO_SUPP; 1005 up_read(&nilfs->ns_sem); 1006 if (features) { 1007 printk(KERN_WARNING "NILFS (device %s): couldn't " 1008 "remount RDWR because of unsupported optional " 1009 "features (%llx)\n", 1010 sb->s_id, (unsigned long long)features); 1011 err = -EROFS; 1012 goto restore_opts; 1013 } 1014 1015 sb->s_flags &= ~MS_RDONLY; 1016 1017 err = nilfs_attach_segment_constructor(sbi); 1018 if (err) 1019 goto restore_opts; 1020 1021 down_write(&nilfs->ns_sem); 1022 nilfs_setup_super(sbi); 1023 up_write(&nilfs->ns_sem); 1024 } 1025 out: 1026 up_write(&nilfs->ns_super_sem); 1027 unlock_kernel(); 1028 return 0; 1029 1030 restore_opts: 1031 sb->s_flags = old_sb_flags; 1032 sbi->s_mount_opt = old_opts.mount_opt; 1033 sbi->s_snapshot_cno = old_opts.snapshot_cno; 1034 up_write(&nilfs->ns_super_sem); 1035 unlock_kernel(); 1036 return err; 1037 } 1038 1039 struct nilfs_super_data { 1040 struct block_device *bdev; 1041 struct nilfs_sb_info *sbi; 1042 __u64 cno; 1043 int flags; 1044 }; 1045 1046 /** 1047 * nilfs_identify - pre-read mount options needed to identify mount instance 1048 * @data: mount options 1049 * @sd: nilfs_super_data 1050 */ 1051 static int nilfs_identify(char *data, struct nilfs_super_data *sd) 1052 { 1053 char *p, *options = data; 1054 substring_t args[MAX_OPT_ARGS]; 1055 int option, token; 1056 int ret = 0; 1057 1058 do { 1059 p = strsep(&options, ","); 1060 if (p != NULL && *p) { 1061 token = match_token(p, tokens, args); 1062 if (token == Opt_snapshot) { 1063 if (!(sd->flags & MS_RDONLY)) 1064 ret++; 1065 else { 1066 ret = match_int(&args[0], &option); 1067 if (!ret) { 1068 if (option > 0) 1069 sd->cno = option; 1070 else 1071 ret++; 1072 } 1073 } 1074 } 1075 if (ret) 1076 printk(KERN_ERR 1077 "NILFS: invalid mount option: %s\n", p); 1078 } 1079 if (!options) 1080 break; 1081 BUG_ON(options == data); 1082 *(options - 1) = ','; 1083 } while (!ret); 1084 return ret; 1085 } 1086 1087 static int nilfs_set_bdev_super(struct super_block *s, void *data) 1088 { 1089 struct nilfs_super_data *sd = data; 1090 1091 s->s_bdev = sd->bdev; 1092 s->s_dev = s->s_bdev->bd_dev; 1093 return 0; 1094 } 1095 1096 static int nilfs_test_bdev_super(struct super_block *s, void *data) 1097 { 1098 struct nilfs_super_data *sd = data; 1099 1100 return sd->sbi && s->s_fs_info == (void *)sd->sbi; 1101 } 1102 1103 static int 1104 nilfs_get_sb(struct file_system_type *fs_type, int flags, 1105 const char *dev_name, void *data, struct vfsmount *mnt) 1106 { 1107 struct nilfs_super_data sd; 1108 struct super_block *s; 1109 fmode_t mode = FMODE_READ; 1110 struct the_nilfs *nilfs; 1111 int err, need_to_close = 1; 1112 1113 if (!(flags & MS_RDONLY)) 1114 mode |= FMODE_WRITE; 1115 1116 sd.bdev = open_bdev_exclusive(dev_name, mode, fs_type); 1117 if (IS_ERR(sd.bdev)) 1118 return PTR_ERR(sd.bdev); 1119 1120 /* 1121 * To get mount instance using sget() vfs-routine, NILFS needs 1122 * much more information than normal filesystems to identify mount 1123 * instance. For snapshot mounts, not only a mount type (ro-mount 1124 * or rw-mount) but also a checkpoint number is required. 1125 */ 1126 sd.cno = 0; 1127 sd.flags = flags; 1128 if (nilfs_identify((char *)data, &sd)) { 1129 err = -EINVAL; 1130 goto failed; 1131 } 1132 1133 nilfs = find_or_create_nilfs(sd.bdev); 1134 if (!nilfs) { 1135 err = -ENOMEM; 1136 goto failed; 1137 } 1138 1139 mutex_lock(&nilfs->ns_mount_mutex); 1140 1141 if (!sd.cno) { 1142 /* 1143 * Check if an exclusive mount exists or not. 1144 * Snapshot mounts coexist with a current mount 1145 * (i.e. rw-mount or ro-mount), whereas rw-mount and 1146 * ro-mount are mutually exclusive. 1147 */ 1148 down_read(&nilfs->ns_super_sem); 1149 if (nilfs->ns_current && 1150 ((nilfs->ns_current->s_super->s_flags ^ flags) 1151 & MS_RDONLY)) { 1152 up_read(&nilfs->ns_super_sem); 1153 err = -EBUSY; 1154 goto failed_unlock; 1155 } 1156 up_read(&nilfs->ns_super_sem); 1157 } 1158 1159 /* 1160 * Find existing nilfs_sb_info struct 1161 */ 1162 sd.sbi = nilfs_find_sbinfo(nilfs, !(flags & MS_RDONLY), sd.cno); 1163 1164 /* 1165 * Get super block instance holding the nilfs_sb_info struct. 1166 * A new instance is allocated if no existing mount is present or 1167 * existing instance has been unmounted. 1168 */ 1169 s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd); 1170 if (sd.sbi) 1171 nilfs_put_sbinfo(sd.sbi); 1172 1173 if (IS_ERR(s)) { 1174 err = PTR_ERR(s); 1175 goto failed_unlock; 1176 } 1177 1178 if (!s->s_root) { 1179 char b[BDEVNAME_SIZE]; 1180 1181 /* New superblock instance created */ 1182 s->s_flags = flags; 1183 s->s_mode = mode; 1184 strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id)); 1185 sb_set_blocksize(s, block_size(sd.bdev)); 1186 1187 err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0, 1188 nilfs); 1189 if (err) 1190 goto cancel_new; 1191 1192 s->s_flags |= MS_ACTIVE; 1193 need_to_close = 0; 1194 } 1195 1196 mutex_unlock(&nilfs->ns_mount_mutex); 1197 put_nilfs(nilfs); 1198 if (need_to_close) 1199 close_bdev_exclusive(sd.bdev, mode); 1200 simple_set_mnt(mnt, s); 1201 return 0; 1202 1203 failed_unlock: 1204 mutex_unlock(&nilfs->ns_mount_mutex); 1205 put_nilfs(nilfs); 1206 failed: 1207 close_bdev_exclusive(sd.bdev, mode); 1208 1209 return err; 1210 1211 cancel_new: 1212 /* Abandoning the newly allocated superblock */ 1213 mutex_unlock(&nilfs->ns_mount_mutex); 1214 put_nilfs(nilfs); 1215 deactivate_locked_super(s); 1216 /* 1217 * deactivate_locked_super() invokes close_bdev_exclusive(). 1218 * We must finish all post-cleaning before this call; 1219 * put_nilfs() needs the block device. 1220 */ 1221 return err; 1222 } 1223 1224 struct file_system_type nilfs_fs_type = { 1225 .owner = THIS_MODULE, 1226 .name = "nilfs2", 1227 .get_sb = nilfs_get_sb, 1228 .kill_sb = kill_block_super, 1229 .fs_flags = FS_REQUIRES_DEV, 1230 }; 1231 1232 static void nilfs_inode_init_once(void *obj) 1233 { 1234 struct nilfs_inode_info *ii = obj; 1235 1236 INIT_LIST_HEAD(&ii->i_dirty); 1237 #ifdef CONFIG_NILFS_XATTR 1238 init_rwsem(&ii->xattr_sem); 1239 #endif 1240 nilfs_btnode_cache_init_once(&ii->i_btnode_cache); 1241 ii->i_bmap = &ii->i_bmap_data; 1242 inode_init_once(&ii->vfs_inode); 1243 } 1244 1245 static void nilfs_segbuf_init_once(void *obj) 1246 { 1247 memset(obj, 0, sizeof(struct nilfs_segment_buffer)); 1248 } 1249 1250 static void nilfs_destroy_cachep(void) 1251 { 1252 if (nilfs_inode_cachep) 1253 kmem_cache_destroy(nilfs_inode_cachep); 1254 if (nilfs_transaction_cachep) 1255 kmem_cache_destroy(nilfs_transaction_cachep); 1256 if (nilfs_segbuf_cachep) 1257 kmem_cache_destroy(nilfs_segbuf_cachep); 1258 if (nilfs_btree_path_cache) 1259 kmem_cache_destroy(nilfs_btree_path_cache); 1260 } 1261 1262 static int __init nilfs_init_cachep(void) 1263 { 1264 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", 1265 sizeof(struct nilfs_inode_info), 0, 1266 SLAB_RECLAIM_ACCOUNT, nilfs_inode_init_once); 1267 if (!nilfs_inode_cachep) 1268 goto fail; 1269 1270 nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache", 1271 sizeof(struct nilfs_transaction_info), 0, 1272 SLAB_RECLAIM_ACCOUNT, NULL); 1273 if (!nilfs_transaction_cachep) 1274 goto fail; 1275 1276 nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache", 1277 sizeof(struct nilfs_segment_buffer), 0, 1278 SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once); 1279 if (!nilfs_segbuf_cachep) 1280 goto fail; 1281 1282 nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache", 1283 sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX, 1284 0, 0, NULL); 1285 if (!nilfs_btree_path_cache) 1286 goto fail; 1287 1288 return 0; 1289 1290 fail: 1291 nilfs_destroy_cachep(); 1292 return -ENOMEM; 1293 } 1294 1295 static int __init init_nilfs_fs(void) 1296 { 1297 int err; 1298 1299 err = nilfs_init_cachep(); 1300 if (err) 1301 goto fail; 1302 1303 err = register_filesystem(&nilfs_fs_type); 1304 if (err) 1305 goto free_cachep; 1306 1307 printk(KERN_INFO "NILFS version 2 loaded\n"); 1308 return 0; 1309 1310 free_cachep: 1311 nilfs_destroy_cachep(); 1312 fail: 1313 return err; 1314 } 1315 1316 static void __exit exit_nilfs_fs(void) 1317 { 1318 nilfs_destroy_cachep(); 1319 unregister_filesystem(&nilfs_fs_type); 1320 } 1321 1322 module_init(init_nilfs_fs) 1323 module_exit(exit_nilfs_fs) 1324