1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * NILFS module and super block management. 4 * 5 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 6 * 7 * Written by Ryusuke Konishi. 8 */ 9 /* 10 * linux/fs/ext2/super.c 11 * 12 * Copyright (C) 1992, 1993, 1994, 1995 13 * Remy Card (card@masi.ibp.fr) 14 * Laboratoire MASI - Institut Blaise Pascal 15 * Universite Pierre et Marie Curie (Paris VI) 16 * 17 * from 18 * 19 * linux/fs/minix/inode.c 20 * 21 * Copyright (C) 1991, 1992 Linus Torvalds 22 * 23 * Big-endian to little-endian byte-swapping/bitmaps by 24 * David S. Miller (davem@caip.rutgers.edu), 1995 25 */ 26 27 #include <linux/module.h> 28 #include <linux/string.h> 29 #include <linux/slab.h> 30 #include <linux/init.h> 31 #include <linux/blkdev.h> 32 #include <linux/crc32.h> 33 #include <linux/vfs.h> 34 #include <linux/writeback.h> 35 #include <linux/seq_file.h> 36 #include <linux/mount.h> 37 #include <linux/fs_context.h> 38 #include <linux/fs_parser.h> 39 #include "nilfs.h" 40 #include "export.h" 41 #include "mdt.h" 42 #include "alloc.h" 43 #include "btree.h" 44 #include "btnode.h" 45 #include "page.h" 46 #include "cpfile.h" 47 #include "sufile.h" /* nilfs_sufile_resize(), nilfs_sufile_set_alloc_range() */ 48 #include "ifile.h" 49 #include "dat.h" 50 #include "segment.h" 51 #include "segbuf.h" 52 53 MODULE_AUTHOR("NTT Corp."); 54 MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem " 55 "(NILFS)"); 56 MODULE_LICENSE("GPL"); 57 58 static struct kmem_cache *nilfs_inode_cachep; 59 struct kmem_cache *nilfs_transaction_cachep; 60 struct kmem_cache *nilfs_segbuf_cachep; 61 struct kmem_cache *nilfs_btree_path_cache; 62 63 static int nilfs_setup_super(struct super_block *sb, int is_mount); 64 65 void __nilfs_msg(struct super_block *sb, const char *fmt, ...) 66 { 67 struct va_format vaf; 68 va_list args; 69 int level; 70 71 va_start(args, fmt); 72 73 level = printk_get_level(fmt); 74 vaf.fmt = printk_skip_level(fmt); 75 vaf.va = &args; 76 77 if (sb) 78 printk("%c%cNILFS (%s): %pV\n", 79 KERN_SOH_ASCII, level, sb->s_id, &vaf); 80 else 81 printk("%c%cNILFS: %pV\n", 82 KERN_SOH_ASCII, level, &vaf); 83 84 va_end(args); 85 } 86 87 static void nilfs_set_error(struct super_block *sb) 88 { 89 struct the_nilfs *nilfs = sb->s_fs_info; 90 struct nilfs_super_block **sbp; 91 92 down_write(&nilfs->ns_sem); 93 if (!(nilfs->ns_mount_state & NILFS_ERROR_FS)) { 94 nilfs->ns_mount_state |= NILFS_ERROR_FS; 95 sbp = nilfs_prepare_super(sb, 0); 96 if (likely(sbp)) { 97 sbp[0]->s_state |= cpu_to_le16(NILFS_ERROR_FS); 98 if (sbp[1]) 99 sbp[1]->s_state |= cpu_to_le16(NILFS_ERROR_FS); 100 nilfs_commit_super(sb, NILFS_SB_COMMIT_ALL); 101 } 102 } 103 up_write(&nilfs->ns_sem); 104 } 105 106 /** 107 * __nilfs_error() - report failure condition on a filesystem 108 * 109 * __nilfs_error() sets an ERROR_FS flag on the superblock as well as 110 * reporting an error message. This function should be called when 111 * NILFS detects incoherences or defects of meta data on disk. 112 * 113 * This implements the body of nilfs_error() macro. Normally, 114 * nilfs_error() should be used. As for sustainable errors such as a 115 * single-shot I/O error, nilfs_err() should be used instead. 116 * 117 * Callers should not add a trailing newline since this will do it. 118 */ 119 void __nilfs_error(struct super_block *sb, const char *function, 120 const char *fmt, ...) 121 { 122 struct the_nilfs *nilfs = sb->s_fs_info; 123 struct va_format vaf; 124 va_list args; 125 126 va_start(args, fmt); 127 128 vaf.fmt = fmt; 129 vaf.va = &args; 130 131 printk(KERN_CRIT "NILFS error (device %s): %s: %pV\n", 132 sb->s_id, function, &vaf); 133 134 va_end(args); 135 136 if (!sb_rdonly(sb)) { 137 nilfs_set_error(sb); 138 139 if (nilfs_test_opt(nilfs, ERRORS_RO)) { 140 printk(KERN_CRIT "Remounting filesystem read-only\n"); 141 sb->s_flags |= SB_RDONLY; 142 } 143 } 144 145 if (nilfs_test_opt(nilfs, ERRORS_PANIC)) 146 panic("NILFS (device %s): panic forced after error\n", 147 sb->s_id); 148 } 149 150 struct inode *nilfs_alloc_inode(struct super_block *sb) 151 { 152 struct nilfs_inode_info *ii; 153 154 ii = alloc_inode_sb(sb, nilfs_inode_cachep, GFP_NOFS); 155 if (!ii) 156 return NULL; 157 ii->i_bh = NULL; 158 ii->i_state = 0; 159 ii->i_cno = 0; 160 ii->i_assoc_inode = NULL; 161 ii->i_bmap = &ii->i_bmap_data; 162 return &ii->vfs_inode; 163 } 164 165 static void nilfs_free_inode(struct inode *inode) 166 { 167 if (nilfs_is_metadata_file_inode(inode)) 168 nilfs_mdt_destroy(inode); 169 170 kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode)); 171 } 172 173 static int nilfs_sync_super(struct super_block *sb, int flag) 174 { 175 struct the_nilfs *nilfs = sb->s_fs_info; 176 int err; 177 178 retry: 179 set_buffer_dirty(nilfs->ns_sbh[0]); 180 if (nilfs_test_opt(nilfs, BARRIER)) { 181 err = __sync_dirty_buffer(nilfs->ns_sbh[0], 182 REQ_SYNC | REQ_PREFLUSH | REQ_FUA); 183 } else { 184 err = sync_dirty_buffer(nilfs->ns_sbh[0]); 185 } 186 187 if (unlikely(err)) { 188 nilfs_err(sb, "unable to write superblock: err=%d", err); 189 if (err == -EIO && nilfs->ns_sbh[1]) { 190 /* 191 * sbp[0] points to newer log than sbp[1], 192 * so copy sbp[0] to sbp[1] to take over sbp[0]. 193 */ 194 memcpy(nilfs->ns_sbp[1], nilfs->ns_sbp[0], 195 nilfs->ns_sbsize); 196 nilfs_fall_back_super_block(nilfs); 197 goto retry; 198 } 199 } else { 200 struct nilfs_super_block *sbp = nilfs->ns_sbp[0]; 201 202 nilfs->ns_sbwcount++; 203 204 /* 205 * The latest segment becomes trailable from the position 206 * written in superblock. 207 */ 208 clear_nilfs_discontinued(nilfs); 209 210 /* update GC protection for recent segments */ 211 if (nilfs->ns_sbh[1]) { 212 if (flag == NILFS_SB_COMMIT_ALL) { 213 set_buffer_dirty(nilfs->ns_sbh[1]); 214 if (sync_dirty_buffer(nilfs->ns_sbh[1]) < 0) 215 goto out; 216 } 217 if (le64_to_cpu(nilfs->ns_sbp[1]->s_last_cno) < 218 le64_to_cpu(nilfs->ns_sbp[0]->s_last_cno)) 219 sbp = nilfs->ns_sbp[1]; 220 } 221 222 spin_lock(&nilfs->ns_last_segment_lock); 223 nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq); 224 spin_unlock(&nilfs->ns_last_segment_lock); 225 } 226 out: 227 return err; 228 } 229 230 void nilfs_set_log_cursor(struct nilfs_super_block *sbp, 231 struct the_nilfs *nilfs) 232 { 233 sector_t nfreeblocks; 234 235 /* nilfs->ns_sem must be locked by the caller. */ 236 nilfs_count_free_blocks(nilfs, &nfreeblocks); 237 sbp->s_free_blocks_count = cpu_to_le64(nfreeblocks); 238 239 spin_lock(&nilfs->ns_last_segment_lock); 240 sbp->s_last_seq = cpu_to_le64(nilfs->ns_last_seq); 241 sbp->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg); 242 sbp->s_last_cno = cpu_to_le64(nilfs->ns_last_cno); 243 spin_unlock(&nilfs->ns_last_segment_lock); 244 } 245 246 struct nilfs_super_block **nilfs_prepare_super(struct super_block *sb, 247 int flip) 248 { 249 struct the_nilfs *nilfs = sb->s_fs_info; 250 struct nilfs_super_block **sbp = nilfs->ns_sbp; 251 252 /* nilfs->ns_sem must be locked by the caller. */ 253 if (sbp[0]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 254 if (sbp[1] && 255 sbp[1]->s_magic == cpu_to_le16(NILFS_SUPER_MAGIC)) { 256 memcpy(sbp[0], sbp[1], nilfs->ns_sbsize); 257 } else { 258 nilfs_crit(sb, "superblock broke"); 259 return NULL; 260 } 261 } else if (sbp[1] && 262 sbp[1]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 263 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 264 } 265 266 if (flip && sbp[1]) 267 nilfs_swap_super_block(nilfs); 268 269 return sbp; 270 } 271 272 int nilfs_commit_super(struct super_block *sb, int flag) 273 { 274 struct the_nilfs *nilfs = sb->s_fs_info; 275 struct nilfs_super_block **sbp = nilfs->ns_sbp; 276 time64_t t; 277 278 /* nilfs->ns_sem must be locked by the caller. */ 279 t = ktime_get_real_seconds(); 280 nilfs->ns_sbwtime = t; 281 sbp[0]->s_wtime = cpu_to_le64(t); 282 sbp[0]->s_sum = 0; 283 sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 284 (unsigned char *)sbp[0], 285 nilfs->ns_sbsize)); 286 if (flag == NILFS_SB_COMMIT_ALL && sbp[1]) { 287 sbp[1]->s_wtime = sbp[0]->s_wtime; 288 sbp[1]->s_sum = 0; 289 sbp[1]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 290 (unsigned char *)sbp[1], 291 nilfs->ns_sbsize)); 292 } 293 clear_nilfs_sb_dirty(nilfs); 294 nilfs->ns_flushed_device = 1; 295 /* make sure store to ns_flushed_device cannot be reordered */ 296 smp_wmb(); 297 return nilfs_sync_super(sb, flag); 298 } 299 300 /** 301 * nilfs_cleanup_super() - write filesystem state for cleanup 302 * @sb: super block instance to be unmounted or degraded to read-only 303 * 304 * This function restores state flags in the on-disk super block. 305 * This will set "clean" flag (i.e. NILFS_VALID_FS) unless the 306 * filesystem was not clean previously. 307 */ 308 int nilfs_cleanup_super(struct super_block *sb) 309 { 310 struct the_nilfs *nilfs = sb->s_fs_info; 311 struct nilfs_super_block **sbp; 312 int flag = NILFS_SB_COMMIT; 313 int ret = -EIO; 314 315 sbp = nilfs_prepare_super(sb, 0); 316 if (sbp) { 317 sbp[0]->s_state = cpu_to_le16(nilfs->ns_mount_state); 318 nilfs_set_log_cursor(sbp[0], nilfs); 319 if (sbp[1] && sbp[0]->s_last_cno == sbp[1]->s_last_cno) { 320 /* 321 * make the "clean" flag also to the opposite 322 * super block if both super blocks point to 323 * the same checkpoint. 324 */ 325 sbp[1]->s_state = sbp[0]->s_state; 326 flag = NILFS_SB_COMMIT_ALL; 327 } 328 ret = nilfs_commit_super(sb, flag); 329 } 330 return ret; 331 } 332 333 /** 334 * nilfs_move_2nd_super - relocate secondary super block 335 * @sb: super block instance 336 * @sb2off: new offset of the secondary super block (in bytes) 337 */ 338 static int nilfs_move_2nd_super(struct super_block *sb, loff_t sb2off) 339 { 340 struct the_nilfs *nilfs = sb->s_fs_info; 341 struct buffer_head *nsbh; 342 struct nilfs_super_block *nsbp; 343 sector_t blocknr, newblocknr; 344 unsigned long offset; 345 int sb2i; /* array index of the secondary superblock */ 346 int ret = 0; 347 348 /* nilfs->ns_sem must be locked by the caller. */ 349 if (nilfs->ns_sbh[1] && 350 nilfs->ns_sbh[1]->b_blocknr > nilfs->ns_first_data_block) { 351 sb2i = 1; 352 blocknr = nilfs->ns_sbh[1]->b_blocknr; 353 } else if (nilfs->ns_sbh[0]->b_blocknr > nilfs->ns_first_data_block) { 354 sb2i = 0; 355 blocknr = nilfs->ns_sbh[0]->b_blocknr; 356 } else { 357 sb2i = -1; 358 blocknr = 0; 359 } 360 if (sb2i >= 0 && (u64)blocknr << nilfs->ns_blocksize_bits == sb2off) 361 goto out; /* super block location is unchanged */ 362 363 /* Get new super block buffer */ 364 newblocknr = sb2off >> nilfs->ns_blocksize_bits; 365 offset = sb2off & (nilfs->ns_blocksize - 1); 366 nsbh = sb_getblk(sb, newblocknr); 367 if (!nsbh) { 368 nilfs_warn(sb, 369 "unable to move secondary superblock to block %llu", 370 (unsigned long long)newblocknr); 371 ret = -EIO; 372 goto out; 373 } 374 nsbp = (void *)nsbh->b_data + offset; 375 376 lock_buffer(nsbh); 377 if (sb2i >= 0) { 378 /* 379 * The position of the second superblock only changes by 4KiB, 380 * which is larger than the maximum superblock data size 381 * (= 1KiB), so there is no need to use memmove() to allow 382 * overlap between source and destination. 383 */ 384 memcpy(nsbp, nilfs->ns_sbp[sb2i], nilfs->ns_sbsize); 385 386 /* 387 * Zero fill after copy to avoid overwriting in case of move 388 * within the same block. 389 */ 390 memset(nsbh->b_data, 0, offset); 391 memset((void *)nsbp + nilfs->ns_sbsize, 0, 392 nsbh->b_size - offset - nilfs->ns_sbsize); 393 } else { 394 memset(nsbh->b_data, 0, nsbh->b_size); 395 } 396 set_buffer_uptodate(nsbh); 397 unlock_buffer(nsbh); 398 399 if (sb2i >= 0) { 400 brelse(nilfs->ns_sbh[sb2i]); 401 nilfs->ns_sbh[sb2i] = nsbh; 402 nilfs->ns_sbp[sb2i] = nsbp; 403 } else if (nilfs->ns_sbh[0]->b_blocknr < nilfs->ns_first_data_block) { 404 /* secondary super block will be restored to index 1 */ 405 nilfs->ns_sbh[1] = nsbh; 406 nilfs->ns_sbp[1] = nsbp; 407 } else { 408 brelse(nsbh); 409 } 410 out: 411 return ret; 412 } 413 414 /** 415 * nilfs_resize_fs - resize the filesystem 416 * @sb: super block instance 417 * @newsize: new size of the filesystem (in bytes) 418 */ 419 int nilfs_resize_fs(struct super_block *sb, __u64 newsize) 420 { 421 struct the_nilfs *nilfs = sb->s_fs_info; 422 struct nilfs_super_block **sbp; 423 __u64 devsize, newnsegs; 424 loff_t sb2off; 425 int ret; 426 427 ret = -ERANGE; 428 devsize = bdev_nr_bytes(sb->s_bdev); 429 if (newsize > devsize) 430 goto out; 431 432 /* 433 * Prevent underflow in second superblock position calculation. 434 * The exact minimum size check is done in nilfs_sufile_resize(). 435 */ 436 if (newsize < 4096) { 437 ret = -ENOSPC; 438 goto out; 439 } 440 441 /* 442 * Write lock is required to protect some functions depending 443 * on the number of segments, the number of reserved segments, 444 * and so forth. 445 */ 446 down_write(&nilfs->ns_segctor_sem); 447 448 sb2off = NILFS_SB2_OFFSET_BYTES(newsize); 449 newnsegs = sb2off >> nilfs->ns_blocksize_bits; 450 newnsegs = div64_ul(newnsegs, nilfs->ns_blocks_per_segment); 451 452 ret = nilfs_sufile_resize(nilfs->ns_sufile, newnsegs); 453 up_write(&nilfs->ns_segctor_sem); 454 if (ret < 0) 455 goto out; 456 457 ret = nilfs_construct_segment(sb); 458 if (ret < 0) 459 goto out; 460 461 down_write(&nilfs->ns_sem); 462 nilfs_move_2nd_super(sb, sb2off); 463 ret = -EIO; 464 sbp = nilfs_prepare_super(sb, 0); 465 if (likely(sbp)) { 466 nilfs_set_log_cursor(sbp[0], nilfs); 467 /* 468 * Drop NILFS_RESIZE_FS flag for compatibility with 469 * mount-time resize which may be implemented in a 470 * future release. 471 */ 472 sbp[0]->s_state = cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & 473 ~NILFS_RESIZE_FS); 474 sbp[0]->s_dev_size = cpu_to_le64(newsize); 475 sbp[0]->s_nsegments = cpu_to_le64(nilfs->ns_nsegments); 476 if (sbp[1]) 477 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 478 ret = nilfs_commit_super(sb, NILFS_SB_COMMIT_ALL); 479 } 480 up_write(&nilfs->ns_sem); 481 482 /* 483 * Reset the range of allocatable segments last. This order 484 * is important in the case of expansion because the secondary 485 * superblock must be protected from log write until migration 486 * completes. 487 */ 488 if (!ret) 489 nilfs_sufile_set_alloc_range(nilfs->ns_sufile, 0, newnsegs - 1); 490 out: 491 return ret; 492 } 493 494 static void nilfs_put_super(struct super_block *sb) 495 { 496 struct the_nilfs *nilfs = sb->s_fs_info; 497 498 nilfs_detach_log_writer(sb); 499 500 if (!sb_rdonly(sb)) { 501 down_write(&nilfs->ns_sem); 502 nilfs_cleanup_super(sb); 503 up_write(&nilfs->ns_sem); 504 } 505 506 nilfs_sysfs_delete_device_group(nilfs); 507 iput(nilfs->ns_sufile); 508 iput(nilfs->ns_cpfile); 509 iput(nilfs->ns_dat); 510 511 destroy_nilfs(nilfs); 512 sb->s_fs_info = NULL; 513 } 514 515 static int nilfs_sync_fs(struct super_block *sb, int wait) 516 { 517 struct the_nilfs *nilfs = sb->s_fs_info; 518 struct nilfs_super_block **sbp; 519 int err = 0; 520 521 /* This function is called when super block should be written back */ 522 if (wait) 523 err = nilfs_construct_segment(sb); 524 525 down_write(&nilfs->ns_sem); 526 if (nilfs_sb_dirty(nilfs)) { 527 sbp = nilfs_prepare_super(sb, nilfs_sb_will_flip(nilfs)); 528 if (likely(sbp)) { 529 nilfs_set_log_cursor(sbp[0], nilfs); 530 nilfs_commit_super(sb, NILFS_SB_COMMIT); 531 } 532 } 533 up_write(&nilfs->ns_sem); 534 535 if (!err) 536 err = nilfs_flush_device(nilfs); 537 538 return err; 539 } 540 541 int nilfs_attach_checkpoint(struct super_block *sb, __u64 cno, int curr_mnt, 542 struct nilfs_root **rootp) 543 { 544 struct the_nilfs *nilfs = sb->s_fs_info; 545 struct nilfs_root *root; 546 int err = -ENOMEM; 547 548 root = nilfs_find_or_create_root( 549 nilfs, curr_mnt ? NILFS_CPTREE_CURRENT_CNO : cno); 550 if (!root) 551 return err; 552 553 if (root->ifile) 554 goto reuse; /* already attached checkpoint */ 555 556 down_read(&nilfs->ns_segctor_sem); 557 err = nilfs_ifile_read(sb, root, cno, nilfs->ns_inode_size); 558 up_read(&nilfs->ns_segctor_sem); 559 if (unlikely(err)) 560 goto failed; 561 562 reuse: 563 *rootp = root; 564 return 0; 565 566 failed: 567 if (err == -EINVAL) 568 nilfs_err(sb, "Invalid checkpoint (checkpoint number=%llu)", 569 (unsigned long long)cno); 570 nilfs_put_root(root); 571 572 return err; 573 } 574 575 static int nilfs_freeze(struct super_block *sb) 576 { 577 struct the_nilfs *nilfs = sb->s_fs_info; 578 int err; 579 580 if (sb_rdonly(sb)) 581 return 0; 582 583 /* Mark super block clean */ 584 down_write(&nilfs->ns_sem); 585 err = nilfs_cleanup_super(sb); 586 up_write(&nilfs->ns_sem); 587 return err; 588 } 589 590 static int nilfs_unfreeze(struct super_block *sb) 591 { 592 struct the_nilfs *nilfs = sb->s_fs_info; 593 594 if (sb_rdonly(sb)) 595 return 0; 596 597 down_write(&nilfs->ns_sem); 598 nilfs_setup_super(sb, false); 599 up_write(&nilfs->ns_sem); 600 return 0; 601 } 602 603 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 604 { 605 struct super_block *sb = dentry->d_sb; 606 struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root; 607 struct the_nilfs *nilfs = root->nilfs; 608 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 609 unsigned long long blocks; 610 unsigned long overhead; 611 unsigned long nrsvblocks; 612 sector_t nfreeblocks; 613 u64 nmaxinodes, nfreeinodes; 614 int err; 615 616 /* 617 * Compute all of the segment blocks 618 * 619 * The blocks before first segment and after last segment 620 * are excluded. 621 */ 622 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments 623 - nilfs->ns_first_data_block; 624 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment; 625 626 /* 627 * Compute the overhead 628 * 629 * When distributing meta data blocks outside segment structure, 630 * We must count them as the overhead. 631 */ 632 overhead = 0; 633 634 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 635 if (unlikely(err)) 636 return err; 637 638 err = nilfs_ifile_count_free_inodes(root->ifile, 639 &nmaxinodes, &nfreeinodes); 640 if (unlikely(err)) { 641 nilfs_warn(sb, "failed to count free inodes: err=%d", err); 642 if (err == -ERANGE) { 643 /* 644 * If nilfs_palloc_count_max_entries() returns 645 * -ERANGE error code then we simply treat 646 * curent inodes count as maximum possible and 647 * zero as free inodes value. 648 */ 649 nmaxinodes = atomic64_read(&root->inodes_count); 650 nfreeinodes = 0; 651 err = 0; 652 } else 653 return err; 654 } 655 656 buf->f_type = NILFS_SUPER_MAGIC; 657 buf->f_bsize = sb->s_blocksize; 658 buf->f_blocks = blocks - overhead; 659 buf->f_bfree = nfreeblocks; 660 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? 661 (buf->f_bfree - nrsvblocks) : 0; 662 buf->f_files = nmaxinodes; 663 buf->f_ffree = nfreeinodes; 664 buf->f_namelen = NILFS_NAME_LEN; 665 buf->f_fsid = u64_to_fsid(id); 666 667 return 0; 668 } 669 670 static int nilfs_show_options(struct seq_file *seq, struct dentry *dentry) 671 { 672 struct super_block *sb = dentry->d_sb; 673 struct the_nilfs *nilfs = sb->s_fs_info; 674 struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root; 675 676 if (!nilfs_test_opt(nilfs, BARRIER)) 677 seq_puts(seq, ",nobarrier"); 678 if (root->cno != NILFS_CPTREE_CURRENT_CNO) 679 seq_printf(seq, ",cp=%llu", (unsigned long long)root->cno); 680 if (nilfs_test_opt(nilfs, ERRORS_PANIC)) 681 seq_puts(seq, ",errors=panic"); 682 if (nilfs_test_opt(nilfs, ERRORS_CONT)) 683 seq_puts(seq, ",errors=continue"); 684 if (nilfs_test_opt(nilfs, STRICT_ORDER)) 685 seq_puts(seq, ",order=strict"); 686 if (nilfs_test_opt(nilfs, NORECOVERY)) 687 seq_puts(seq, ",norecovery"); 688 if (nilfs_test_opt(nilfs, DISCARD)) 689 seq_puts(seq, ",discard"); 690 691 return 0; 692 } 693 694 static const struct super_operations nilfs_sops = { 695 .alloc_inode = nilfs_alloc_inode, 696 .free_inode = nilfs_free_inode, 697 .dirty_inode = nilfs_dirty_inode, 698 .evict_inode = nilfs_evict_inode, 699 .put_super = nilfs_put_super, 700 .sync_fs = nilfs_sync_fs, 701 .freeze_fs = nilfs_freeze, 702 .unfreeze_fs = nilfs_unfreeze, 703 .statfs = nilfs_statfs, 704 .show_options = nilfs_show_options 705 }; 706 707 enum { 708 Opt_err, Opt_barrier, Opt_snapshot, Opt_order, Opt_norecovery, 709 Opt_discard, 710 }; 711 712 static const struct constant_table nilfs_param_err[] = { 713 {"continue", NILFS_MOUNT_ERRORS_CONT}, 714 {"panic", NILFS_MOUNT_ERRORS_PANIC}, 715 {"remount-ro", NILFS_MOUNT_ERRORS_RO}, 716 {} 717 }; 718 719 static const struct fs_parameter_spec nilfs_param_spec[] = { 720 fsparam_enum ("errors", Opt_err, nilfs_param_err), 721 fsparam_flag_no ("barrier", Opt_barrier), 722 fsparam_u64 ("cp", Opt_snapshot), 723 fsparam_string ("order", Opt_order), 724 fsparam_flag ("norecovery", Opt_norecovery), 725 fsparam_flag_no ("discard", Opt_discard), 726 {} 727 }; 728 729 struct nilfs_fs_context { 730 unsigned long ns_mount_opt; 731 __u64 cno; 732 }; 733 734 static int nilfs_parse_param(struct fs_context *fc, struct fs_parameter *param) 735 { 736 struct nilfs_fs_context *nilfs = fc->fs_private; 737 int is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE; 738 struct fs_parse_result result; 739 int opt; 740 741 opt = fs_parse(fc, nilfs_param_spec, param, &result); 742 if (opt < 0) 743 return opt; 744 745 switch (opt) { 746 case Opt_barrier: 747 if (result.negated) 748 nilfs_clear_opt(nilfs, BARRIER); 749 else 750 nilfs_set_opt(nilfs, BARRIER); 751 break; 752 case Opt_order: 753 if (strcmp(param->string, "relaxed") == 0) 754 /* Ordered data semantics */ 755 nilfs_clear_opt(nilfs, STRICT_ORDER); 756 else if (strcmp(param->string, "strict") == 0) 757 /* Strict in-order semantics */ 758 nilfs_set_opt(nilfs, STRICT_ORDER); 759 else 760 return -EINVAL; 761 break; 762 case Opt_err: 763 nilfs->ns_mount_opt &= ~NILFS_MOUNT_ERROR_MODE; 764 nilfs->ns_mount_opt |= result.uint_32; 765 break; 766 case Opt_snapshot: 767 if (is_remount) { 768 struct super_block *sb = fc->root->d_sb; 769 770 nilfs_err(sb, 771 "\"%s\" option is invalid for remount", 772 param->key); 773 return -EINVAL; 774 } 775 if (result.uint_64 == 0) { 776 nilfs_err(NULL, 777 "invalid option \"cp=0\": invalid checkpoint number 0"); 778 return -EINVAL; 779 } 780 nilfs->cno = result.uint_64; 781 break; 782 case Opt_norecovery: 783 nilfs_set_opt(nilfs, NORECOVERY); 784 break; 785 case Opt_discard: 786 if (result.negated) 787 nilfs_clear_opt(nilfs, DISCARD); 788 else 789 nilfs_set_opt(nilfs, DISCARD); 790 break; 791 default: 792 return -EINVAL; 793 } 794 795 return 0; 796 } 797 798 static int nilfs_setup_super(struct super_block *sb, int is_mount) 799 { 800 struct the_nilfs *nilfs = sb->s_fs_info; 801 struct nilfs_super_block **sbp; 802 int max_mnt_count; 803 int mnt_count; 804 805 /* nilfs->ns_sem must be locked by the caller. */ 806 sbp = nilfs_prepare_super(sb, 0); 807 if (!sbp) 808 return -EIO; 809 810 if (!is_mount) 811 goto skip_mount_setup; 812 813 max_mnt_count = le16_to_cpu(sbp[0]->s_max_mnt_count); 814 mnt_count = le16_to_cpu(sbp[0]->s_mnt_count); 815 816 if (nilfs->ns_mount_state & NILFS_ERROR_FS) { 817 nilfs_warn(sb, "mounting fs with errors"); 818 #if 0 819 } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) { 820 nilfs_warn(sb, "maximal mount count reached"); 821 #endif 822 } 823 if (!max_mnt_count) 824 sbp[0]->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT); 825 826 sbp[0]->s_mnt_count = cpu_to_le16(mnt_count + 1); 827 sbp[0]->s_mtime = cpu_to_le64(ktime_get_real_seconds()); 828 829 skip_mount_setup: 830 sbp[0]->s_state = 831 cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & ~NILFS_VALID_FS); 832 /* synchronize sbp[1] with sbp[0] */ 833 if (sbp[1]) 834 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 835 return nilfs_commit_super(sb, NILFS_SB_COMMIT_ALL); 836 } 837 838 struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb, 839 u64 pos, int blocksize, 840 struct buffer_head **pbh) 841 { 842 unsigned long long sb_index = pos; 843 unsigned long offset; 844 845 offset = do_div(sb_index, blocksize); 846 *pbh = sb_bread(sb, sb_index); 847 if (!*pbh) 848 return NULL; 849 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset); 850 } 851 852 int nilfs_store_magic(struct super_block *sb, 853 struct nilfs_super_block *sbp) 854 { 855 struct the_nilfs *nilfs = sb->s_fs_info; 856 857 sb->s_magic = le16_to_cpu(sbp->s_magic); 858 859 /* FS independent flags */ 860 #ifdef NILFS_ATIME_DISABLE 861 sb->s_flags |= SB_NOATIME; 862 #endif 863 864 nilfs->ns_resuid = le16_to_cpu(sbp->s_def_resuid); 865 nilfs->ns_resgid = le16_to_cpu(sbp->s_def_resgid); 866 nilfs->ns_interval = le32_to_cpu(sbp->s_c_interval); 867 nilfs->ns_watermark = le32_to_cpu(sbp->s_c_block_max); 868 869 return 0; 870 } 871 872 int nilfs_check_feature_compatibility(struct super_block *sb, 873 struct nilfs_super_block *sbp) 874 { 875 __u64 features; 876 877 features = le64_to_cpu(sbp->s_feature_incompat) & 878 ~NILFS_FEATURE_INCOMPAT_SUPP; 879 if (features) { 880 nilfs_err(sb, 881 "couldn't mount because of unsupported optional features (%llx)", 882 (unsigned long long)features); 883 return -EINVAL; 884 } 885 features = le64_to_cpu(sbp->s_feature_compat_ro) & 886 ~NILFS_FEATURE_COMPAT_RO_SUPP; 887 if (!sb_rdonly(sb) && features) { 888 nilfs_err(sb, 889 "couldn't mount RDWR because of unsupported optional features (%llx)", 890 (unsigned long long)features); 891 return -EINVAL; 892 } 893 return 0; 894 } 895 896 static int nilfs_get_root_dentry(struct super_block *sb, 897 struct nilfs_root *root, 898 struct dentry **root_dentry) 899 { 900 struct inode *inode; 901 struct dentry *dentry; 902 int ret = 0; 903 904 inode = nilfs_iget(sb, root, NILFS_ROOT_INO); 905 if (IS_ERR(inode)) { 906 ret = PTR_ERR(inode); 907 nilfs_err(sb, "error %d getting root inode", ret); 908 goto out; 909 } 910 if (!S_ISDIR(inode->i_mode) || !inode->i_blocks || !inode->i_size) { 911 iput(inode); 912 nilfs_err(sb, "corrupt root inode"); 913 ret = -EINVAL; 914 goto out; 915 } 916 917 if (root->cno == NILFS_CPTREE_CURRENT_CNO) { 918 dentry = d_find_alias(inode); 919 if (!dentry) { 920 dentry = d_make_root(inode); 921 if (!dentry) { 922 ret = -ENOMEM; 923 goto failed_dentry; 924 } 925 } else { 926 iput(inode); 927 } 928 } else { 929 dentry = d_obtain_root(inode); 930 if (IS_ERR(dentry)) { 931 ret = PTR_ERR(dentry); 932 goto failed_dentry; 933 } 934 } 935 *root_dentry = dentry; 936 out: 937 return ret; 938 939 failed_dentry: 940 nilfs_err(sb, "error %d getting root dentry", ret); 941 goto out; 942 } 943 944 static int nilfs_attach_snapshot(struct super_block *s, __u64 cno, 945 struct dentry **root_dentry) 946 { 947 struct the_nilfs *nilfs = s->s_fs_info; 948 struct nilfs_root *root; 949 int ret; 950 951 mutex_lock(&nilfs->ns_snapshot_mount_mutex); 952 953 down_read(&nilfs->ns_segctor_sem); 954 ret = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, cno); 955 up_read(&nilfs->ns_segctor_sem); 956 if (ret < 0) { 957 ret = (ret == -ENOENT) ? -EINVAL : ret; 958 goto out; 959 } else if (!ret) { 960 nilfs_err(s, 961 "The specified checkpoint is not a snapshot (checkpoint number=%llu)", 962 (unsigned long long)cno); 963 ret = -EINVAL; 964 goto out; 965 } 966 967 ret = nilfs_attach_checkpoint(s, cno, false, &root); 968 if (ret) { 969 nilfs_err(s, 970 "error %d while loading snapshot (checkpoint number=%llu)", 971 ret, (unsigned long long)cno); 972 goto out; 973 } 974 ret = nilfs_get_root_dentry(s, root, root_dentry); 975 nilfs_put_root(root); 976 out: 977 mutex_unlock(&nilfs->ns_snapshot_mount_mutex); 978 return ret; 979 } 980 981 /** 982 * nilfs_tree_is_busy() - try to shrink dentries of a checkpoint 983 * @root_dentry: root dentry of the tree to be shrunk 984 * 985 * This function returns true if the tree was in-use. 986 */ 987 static bool nilfs_tree_is_busy(struct dentry *root_dentry) 988 { 989 shrink_dcache_parent(root_dentry); 990 return d_count(root_dentry) > 1; 991 } 992 993 int nilfs_checkpoint_is_mounted(struct super_block *sb, __u64 cno) 994 { 995 struct the_nilfs *nilfs = sb->s_fs_info; 996 struct nilfs_root *root; 997 struct inode *inode; 998 struct dentry *dentry; 999 int ret; 1000 1001 if (cno > nilfs->ns_cno) 1002 return false; 1003 1004 if (cno >= nilfs_last_cno(nilfs)) 1005 return true; /* protect recent checkpoints */ 1006 1007 ret = false; 1008 root = nilfs_lookup_root(nilfs, cno); 1009 if (root) { 1010 inode = nilfs_ilookup(sb, root, NILFS_ROOT_INO); 1011 if (inode) { 1012 dentry = d_find_alias(inode); 1013 if (dentry) { 1014 ret = nilfs_tree_is_busy(dentry); 1015 dput(dentry); 1016 } 1017 iput(inode); 1018 } 1019 nilfs_put_root(root); 1020 } 1021 return ret; 1022 } 1023 1024 /** 1025 * nilfs_fill_super() - initialize a super block instance 1026 * @sb: super_block 1027 * @fc: filesystem context 1028 * 1029 * This function is called exclusively by nilfs->ns_mount_mutex. 1030 * So, the recovery process is protected from other simultaneous mounts. 1031 */ 1032 static int 1033 nilfs_fill_super(struct super_block *sb, struct fs_context *fc) 1034 { 1035 struct the_nilfs *nilfs; 1036 struct nilfs_root *fsroot; 1037 struct nilfs_fs_context *ctx = fc->fs_private; 1038 __u64 cno; 1039 int err; 1040 1041 nilfs = alloc_nilfs(sb); 1042 if (!nilfs) 1043 return -ENOMEM; 1044 1045 sb->s_fs_info = nilfs; 1046 1047 err = init_nilfs(nilfs, sb); 1048 if (err) 1049 goto failed_nilfs; 1050 1051 /* Copy in parsed mount options */ 1052 nilfs->ns_mount_opt = ctx->ns_mount_opt; 1053 1054 sb->s_op = &nilfs_sops; 1055 sb->s_export_op = &nilfs_export_ops; 1056 sb->s_root = NULL; 1057 sb->s_time_gran = 1; 1058 sb->s_max_links = NILFS_LINK_MAX; 1059 1060 sb->s_bdi = bdi_get(sb->s_bdev->bd_disk->bdi); 1061 1062 err = load_nilfs(nilfs, sb); 1063 if (err) 1064 goto failed_nilfs; 1065 1066 cno = nilfs_last_cno(nilfs); 1067 err = nilfs_attach_checkpoint(sb, cno, true, &fsroot); 1068 if (err) { 1069 nilfs_err(sb, 1070 "error %d while loading last checkpoint (checkpoint number=%llu)", 1071 err, (unsigned long long)cno); 1072 goto failed_unload; 1073 } 1074 1075 if (!sb_rdonly(sb)) { 1076 err = nilfs_attach_log_writer(sb, fsroot); 1077 if (err) 1078 goto failed_checkpoint; 1079 } 1080 1081 err = nilfs_get_root_dentry(sb, fsroot, &sb->s_root); 1082 if (err) 1083 goto failed_segctor; 1084 1085 nilfs_put_root(fsroot); 1086 1087 if (!sb_rdonly(sb)) { 1088 down_write(&nilfs->ns_sem); 1089 nilfs_setup_super(sb, true); 1090 up_write(&nilfs->ns_sem); 1091 } 1092 1093 return 0; 1094 1095 failed_segctor: 1096 nilfs_detach_log_writer(sb); 1097 1098 failed_checkpoint: 1099 nilfs_put_root(fsroot); 1100 1101 failed_unload: 1102 nilfs_sysfs_delete_device_group(nilfs); 1103 iput(nilfs->ns_sufile); 1104 iput(nilfs->ns_cpfile); 1105 iput(nilfs->ns_dat); 1106 1107 failed_nilfs: 1108 destroy_nilfs(nilfs); 1109 return err; 1110 } 1111 1112 static int nilfs_reconfigure(struct fs_context *fc) 1113 { 1114 struct nilfs_fs_context *ctx = fc->fs_private; 1115 struct super_block *sb = fc->root->d_sb; 1116 struct the_nilfs *nilfs = sb->s_fs_info; 1117 int err; 1118 1119 sync_filesystem(sb); 1120 1121 err = -EINVAL; 1122 1123 if (!nilfs_valid_fs(nilfs)) { 1124 nilfs_warn(sb, 1125 "couldn't remount because the filesystem is in an incomplete recovery state"); 1126 goto ignore_opts; 1127 } 1128 if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb)) 1129 goto out; 1130 if (fc->sb_flags & SB_RDONLY) { 1131 sb->s_flags |= SB_RDONLY; 1132 1133 /* 1134 * Remounting a valid RW partition RDONLY, so set 1135 * the RDONLY flag and then mark the partition as valid again. 1136 */ 1137 down_write(&nilfs->ns_sem); 1138 nilfs_cleanup_super(sb); 1139 up_write(&nilfs->ns_sem); 1140 } else { 1141 __u64 features; 1142 struct nilfs_root *root; 1143 1144 /* 1145 * Mounting a RDONLY partition read-write, so reread and 1146 * store the current valid flag. (It may have been changed 1147 * by fsck since we originally mounted the partition.) 1148 */ 1149 down_read(&nilfs->ns_sem); 1150 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & 1151 ~NILFS_FEATURE_COMPAT_RO_SUPP; 1152 up_read(&nilfs->ns_sem); 1153 if (features) { 1154 nilfs_warn(sb, 1155 "couldn't remount RDWR because of unsupported optional features (%llx)", 1156 (unsigned long long)features); 1157 err = -EROFS; 1158 goto ignore_opts; 1159 } 1160 1161 sb->s_flags &= ~SB_RDONLY; 1162 1163 root = NILFS_I(d_inode(sb->s_root))->i_root; 1164 err = nilfs_attach_log_writer(sb, root); 1165 if (err) { 1166 sb->s_flags |= SB_RDONLY; 1167 goto ignore_opts; 1168 } 1169 1170 down_write(&nilfs->ns_sem); 1171 nilfs_setup_super(sb, true); 1172 up_write(&nilfs->ns_sem); 1173 } 1174 out: 1175 sb->s_flags = (sb->s_flags & ~SB_POSIXACL); 1176 /* Copy over parsed remount options */ 1177 nilfs->ns_mount_opt = ctx->ns_mount_opt; 1178 1179 return 0; 1180 1181 ignore_opts: 1182 return err; 1183 } 1184 1185 static int 1186 nilfs_get_tree(struct fs_context *fc) 1187 { 1188 struct nilfs_fs_context *ctx = fc->fs_private; 1189 struct super_block *s; 1190 dev_t dev; 1191 int err; 1192 1193 if (ctx->cno && !(fc->sb_flags & SB_RDONLY)) { 1194 nilfs_err(NULL, 1195 "invalid option \"cp=%llu\": read-only option is not specified", 1196 ctx->cno); 1197 return -EINVAL; 1198 } 1199 1200 err = lookup_bdev(fc->source, &dev); 1201 if (err) 1202 return err; 1203 1204 s = sget_dev(fc, dev); 1205 if (IS_ERR(s)) 1206 return PTR_ERR(s); 1207 1208 if (!s->s_root) { 1209 err = setup_bdev_super(s, fc->sb_flags, fc); 1210 if (!err) 1211 err = nilfs_fill_super(s, fc); 1212 if (err) 1213 goto failed_super; 1214 1215 s->s_flags |= SB_ACTIVE; 1216 } else if (!ctx->cno) { 1217 if (nilfs_tree_is_busy(s->s_root)) { 1218 if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) { 1219 nilfs_err(s, 1220 "the device already has a %s mount.", 1221 sb_rdonly(s) ? "read-only" : "read/write"); 1222 err = -EBUSY; 1223 goto failed_super; 1224 } 1225 } else { 1226 /* 1227 * Try reconfigure to setup mount states if the current 1228 * tree is not mounted and only snapshots use this sb. 1229 * 1230 * Since nilfs_reconfigure() requires fc->root to be 1231 * set, set it first and release it on failure. 1232 */ 1233 fc->root = dget(s->s_root); 1234 err = nilfs_reconfigure(fc); 1235 if (err) { 1236 dput(fc->root); 1237 fc->root = NULL; /* prevent double release */ 1238 goto failed_super; 1239 } 1240 return 0; 1241 } 1242 } 1243 1244 if (ctx->cno) { 1245 struct dentry *root_dentry; 1246 1247 err = nilfs_attach_snapshot(s, ctx->cno, &root_dentry); 1248 if (err) 1249 goto failed_super; 1250 fc->root = root_dentry; 1251 return 0; 1252 } 1253 1254 fc->root = dget(s->s_root); 1255 return 0; 1256 1257 failed_super: 1258 deactivate_locked_super(s); 1259 return err; 1260 } 1261 1262 static void nilfs_free_fc(struct fs_context *fc) 1263 { 1264 kfree(fc->fs_private); 1265 } 1266 1267 static const struct fs_context_operations nilfs_context_ops = { 1268 .parse_param = nilfs_parse_param, 1269 .get_tree = nilfs_get_tree, 1270 .reconfigure = nilfs_reconfigure, 1271 .free = nilfs_free_fc, 1272 }; 1273 1274 static int nilfs_init_fs_context(struct fs_context *fc) 1275 { 1276 struct nilfs_fs_context *ctx; 1277 1278 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 1279 if (!ctx) 1280 return -ENOMEM; 1281 1282 ctx->ns_mount_opt = NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER; 1283 fc->fs_private = ctx; 1284 fc->ops = &nilfs_context_ops; 1285 1286 return 0; 1287 } 1288 1289 struct file_system_type nilfs_fs_type = { 1290 .owner = THIS_MODULE, 1291 .name = "nilfs2", 1292 .kill_sb = kill_block_super, 1293 .fs_flags = FS_REQUIRES_DEV, 1294 .init_fs_context = nilfs_init_fs_context, 1295 .parameters = nilfs_param_spec, 1296 }; 1297 MODULE_ALIAS_FS("nilfs2"); 1298 1299 static void nilfs_inode_init_once(void *obj) 1300 { 1301 struct nilfs_inode_info *ii = obj; 1302 1303 INIT_LIST_HEAD(&ii->i_dirty); 1304 #ifdef CONFIG_NILFS_XATTR 1305 init_rwsem(&ii->xattr_sem); 1306 #endif 1307 inode_init_once(&ii->vfs_inode); 1308 } 1309 1310 static void nilfs_segbuf_init_once(void *obj) 1311 { 1312 memset(obj, 0, sizeof(struct nilfs_segment_buffer)); 1313 } 1314 1315 static void nilfs_destroy_cachep(void) 1316 { 1317 /* 1318 * Make sure all delayed rcu free inodes are flushed before we 1319 * destroy cache. 1320 */ 1321 rcu_barrier(); 1322 1323 kmem_cache_destroy(nilfs_inode_cachep); 1324 kmem_cache_destroy(nilfs_transaction_cachep); 1325 kmem_cache_destroy(nilfs_segbuf_cachep); 1326 kmem_cache_destroy(nilfs_btree_path_cache); 1327 } 1328 1329 static int __init nilfs_init_cachep(void) 1330 { 1331 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", 1332 sizeof(struct nilfs_inode_info), 0, 1333 SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, 1334 nilfs_inode_init_once); 1335 if (!nilfs_inode_cachep) 1336 goto fail; 1337 1338 nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache", 1339 sizeof(struct nilfs_transaction_info), 0, 1340 SLAB_RECLAIM_ACCOUNT, NULL); 1341 if (!nilfs_transaction_cachep) 1342 goto fail; 1343 1344 nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache", 1345 sizeof(struct nilfs_segment_buffer), 0, 1346 SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once); 1347 if (!nilfs_segbuf_cachep) 1348 goto fail; 1349 1350 nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache", 1351 sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX, 1352 0, 0, NULL); 1353 if (!nilfs_btree_path_cache) 1354 goto fail; 1355 1356 return 0; 1357 1358 fail: 1359 nilfs_destroy_cachep(); 1360 return -ENOMEM; 1361 } 1362 1363 static int __init init_nilfs_fs(void) 1364 { 1365 int err; 1366 1367 err = nilfs_init_cachep(); 1368 if (err) 1369 goto fail; 1370 1371 err = nilfs_sysfs_init(); 1372 if (err) 1373 goto free_cachep; 1374 1375 err = register_filesystem(&nilfs_fs_type); 1376 if (err) 1377 goto deinit_sysfs_entry; 1378 1379 printk(KERN_INFO "NILFS version 2 loaded\n"); 1380 return 0; 1381 1382 deinit_sysfs_entry: 1383 nilfs_sysfs_exit(); 1384 free_cachep: 1385 nilfs_destroy_cachep(); 1386 fail: 1387 return err; 1388 } 1389 1390 static void __exit exit_nilfs_fs(void) 1391 { 1392 nilfs_destroy_cachep(); 1393 nilfs_sysfs_exit(); 1394 unregister_filesystem(&nilfs_fs_type); 1395 } 1396 1397 module_init(init_nilfs_fs) 1398 module_exit(exit_nilfs_fs) 1399