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