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/parser.h> 33 #include <linux/crc32.h> 34 #include <linux/vfs.h> 35 #include <linux/writeback.h> 36 #include <linux/seq_file.h> 37 #include <linux/mount.h> 38 #include "nilfs.h" 39 #include "export.h" 40 #include "mdt.h" 41 #include "alloc.h" 42 #include "btree.h" 43 #include "btnode.h" 44 #include "page.h" 45 #include "cpfile.h" 46 #include "sufile.h" /* nilfs_sufile_resize(), nilfs_sufile_set_alloc_range() */ 47 #include "ifile.h" 48 #include "dat.h" 49 #include "segment.h" 50 #include "segbuf.h" 51 52 MODULE_AUTHOR("NTT Corp."); 53 MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem " 54 "(NILFS)"); 55 MODULE_LICENSE("GPL"); 56 57 static struct kmem_cache *nilfs_inode_cachep; 58 struct kmem_cache *nilfs_transaction_cachep; 59 struct kmem_cache *nilfs_segbuf_cachep; 60 struct kmem_cache *nilfs_btree_path_cache; 61 62 static int nilfs_setup_super(struct super_block *sb, int is_mount); 63 static int nilfs_remount(struct super_block *sb, int *flags, char *data); 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 do_div(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 struct nilfs_checkpoint *raw_cp; 547 struct buffer_head *bh_cp; 548 int err = -ENOMEM; 549 550 root = nilfs_find_or_create_root( 551 nilfs, curr_mnt ? NILFS_CPTREE_CURRENT_CNO : cno); 552 if (!root) 553 return err; 554 555 if (root->ifile) 556 goto reuse; /* already attached checkpoint */ 557 558 down_read(&nilfs->ns_segctor_sem); 559 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp, 560 &bh_cp); 561 up_read(&nilfs->ns_segctor_sem); 562 if (unlikely(err)) { 563 if (err == -ENOENT || err == -EINVAL) { 564 nilfs_err(sb, 565 "Invalid checkpoint (checkpoint number=%llu)", 566 (unsigned long long)cno); 567 err = -EINVAL; 568 } 569 goto failed; 570 } 571 572 err = nilfs_ifile_read(sb, root, nilfs->ns_inode_size, 573 &raw_cp->cp_ifile_inode, &root->ifile); 574 if (err) 575 goto failed_bh; 576 577 atomic64_set(&root->inodes_count, 578 le64_to_cpu(raw_cp->cp_inodes_count)); 579 atomic64_set(&root->blocks_count, 580 le64_to_cpu(raw_cp->cp_blocks_count)); 581 582 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 583 584 reuse: 585 *rootp = root; 586 return 0; 587 588 failed_bh: 589 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 590 failed: 591 nilfs_put_root(root); 592 593 return err; 594 } 595 596 static int nilfs_freeze(struct super_block *sb) 597 { 598 struct the_nilfs *nilfs = sb->s_fs_info; 599 int err; 600 601 if (sb_rdonly(sb)) 602 return 0; 603 604 /* Mark super block clean */ 605 down_write(&nilfs->ns_sem); 606 err = nilfs_cleanup_super(sb); 607 up_write(&nilfs->ns_sem); 608 return err; 609 } 610 611 static int nilfs_unfreeze(struct super_block *sb) 612 { 613 struct the_nilfs *nilfs = sb->s_fs_info; 614 615 if (sb_rdonly(sb)) 616 return 0; 617 618 down_write(&nilfs->ns_sem); 619 nilfs_setup_super(sb, false); 620 up_write(&nilfs->ns_sem); 621 return 0; 622 } 623 624 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 625 { 626 struct super_block *sb = dentry->d_sb; 627 struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root; 628 struct the_nilfs *nilfs = root->nilfs; 629 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 630 unsigned long long blocks; 631 unsigned long overhead; 632 unsigned long nrsvblocks; 633 sector_t nfreeblocks; 634 u64 nmaxinodes, nfreeinodes; 635 int err; 636 637 /* 638 * Compute all of the segment blocks 639 * 640 * The blocks before first segment and after last segment 641 * are excluded. 642 */ 643 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments 644 - nilfs->ns_first_data_block; 645 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment; 646 647 /* 648 * Compute the overhead 649 * 650 * When distributing meta data blocks outside segment structure, 651 * We must count them as the overhead. 652 */ 653 overhead = 0; 654 655 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 656 if (unlikely(err)) 657 return err; 658 659 err = nilfs_ifile_count_free_inodes(root->ifile, 660 &nmaxinodes, &nfreeinodes); 661 if (unlikely(err)) { 662 nilfs_warn(sb, "failed to count free inodes: err=%d", err); 663 if (err == -ERANGE) { 664 /* 665 * If nilfs_palloc_count_max_entries() returns 666 * -ERANGE error code then we simply treat 667 * curent inodes count as maximum possible and 668 * zero as free inodes value. 669 */ 670 nmaxinodes = atomic64_read(&root->inodes_count); 671 nfreeinodes = 0; 672 err = 0; 673 } else 674 return err; 675 } 676 677 buf->f_type = NILFS_SUPER_MAGIC; 678 buf->f_bsize = sb->s_blocksize; 679 buf->f_blocks = blocks - overhead; 680 buf->f_bfree = nfreeblocks; 681 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? 682 (buf->f_bfree - nrsvblocks) : 0; 683 buf->f_files = nmaxinodes; 684 buf->f_ffree = nfreeinodes; 685 buf->f_namelen = NILFS_NAME_LEN; 686 buf->f_fsid = u64_to_fsid(id); 687 688 return 0; 689 } 690 691 static int nilfs_show_options(struct seq_file *seq, struct dentry *dentry) 692 { 693 struct super_block *sb = dentry->d_sb; 694 struct the_nilfs *nilfs = sb->s_fs_info; 695 struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root; 696 697 if (!nilfs_test_opt(nilfs, BARRIER)) 698 seq_puts(seq, ",nobarrier"); 699 if (root->cno != NILFS_CPTREE_CURRENT_CNO) 700 seq_printf(seq, ",cp=%llu", (unsigned long long)root->cno); 701 if (nilfs_test_opt(nilfs, ERRORS_PANIC)) 702 seq_puts(seq, ",errors=panic"); 703 if (nilfs_test_opt(nilfs, ERRORS_CONT)) 704 seq_puts(seq, ",errors=continue"); 705 if (nilfs_test_opt(nilfs, STRICT_ORDER)) 706 seq_puts(seq, ",order=strict"); 707 if (nilfs_test_opt(nilfs, NORECOVERY)) 708 seq_puts(seq, ",norecovery"); 709 if (nilfs_test_opt(nilfs, DISCARD)) 710 seq_puts(seq, ",discard"); 711 712 return 0; 713 } 714 715 static const struct super_operations nilfs_sops = { 716 .alloc_inode = nilfs_alloc_inode, 717 .free_inode = nilfs_free_inode, 718 .dirty_inode = nilfs_dirty_inode, 719 .evict_inode = nilfs_evict_inode, 720 .put_super = nilfs_put_super, 721 .sync_fs = nilfs_sync_fs, 722 .freeze_fs = nilfs_freeze, 723 .unfreeze_fs = nilfs_unfreeze, 724 .statfs = nilfs_statfs, 725 .remount_fs = nilfs_remount, 726 .show_options = nilfs_show_options 727 }; 728 729 enum { 730 Opt_err_cont, Opt_err_panic, Opt_err_ro, 731 Opt_barrier, Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery, 732 Opt_discard, Opt_nodiscard, Opt_err, 733 }; 734 735 static match_table_t tokens = { 736 {Opt_err_cont, "errors=continue"}, 737 {Opt_err_panic, "errors=panic"}, 738 {Opt_err_ro, "errors=remount-ro"}, 739 {Opt_barrier, "barrier"}, 740 {Opt_nobarrier, "nobarrier"}, 741 {Opt_snapshot, "cp=%u"}, 742 {Opt_order, "order=%s"}, 743 {Opt_norecovery, "norecovery"}, 744 {Opt_discard, "discard"}, 745 {Opt_nodiscard, "nodiscard"}, 746 {Opt_err, NULL} 747 }; 748 749 static int parse_options(char *options, struct super_block *sb, int is_remount) 750 { 751 struct the_nilfs *nilfs = sb->s_fs_info; 752 char *p; 753 substring_t args[MAX_OPT_ARGS]; 754 755 if (!options) 756 return 1; 757 758 while ((p = strsep(&options, ",")) != NULL) { 759 int token; 760 761 if (!*p) 762 continue; 763 764 token = match_token(p, tokens, args); 765 switch (token) { 766 case Opt_barrier: 767 nilfs_set_opt(nilfs, BARRIER); 768 break; 769 case Opt_nobarrier: 770 nilfs_clear_opt(nilfs, BARRIER); 771 break; 772 case Opt_order: 773 if (strcmp(args[0].from, "relaxed") == 0) 774 /* Ordered data semantics */ 775 nilfs_clear_opt(nilfs, STRICT_ORDER); 776 else if (strcmp(args[0].from, "strict") == 0) 777 /* Strict in-order semantics */ 778 nilfs_set_opt(nilfs, STRICT_ORDER); 779 else 780 return 0; 781 break; 782 case Opt_err_panic: 783 nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_PANIC); 784 break; 785 case Opt_err_ro: 786 nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_RO); 787 break; 788 case Opt_err_cont: 789 nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_CONT); 790 break; 791 case Opt_snapshot: 792 if (is_remount) { 793 nilfs_err(sb, 794 "\"%s\" option is invalid for remount", 795 p); 796 return 0; 797 } 798 break; 799 case Opt_norecovery: 800 nilfs_set_opt(nilfs, NORECOVERY); 801 break; 802 case Opt_discard: 803 nilfs_set_opt(nilfs, DISCARD); 804 break; 805 case Opt_nodiscard: 806 nilfs_clear_opt(nilfs, DISCARD); 807 break; 808 default: 809 nilfs_err(sb, "unrecognized mount option \"%s\"", p); 810 return 0; 811 } 812 } 813 return 1; 814 } 815 816 static inline void 817 nilfs_set_default_options(struct super_block *sb, 818 struct nilfs_super_block *sbp) 819 { 820 struct the_nilfs *nilfs = sb->s_fs_info; 821 822 nilfs->ns_mount_opt = 823 NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER; 824 } 825 826 static int nilfs_setup_super(struct super_block *sb, int is_mount) 827 { 828 struct the_nilfs *nilfs = sb->s_fs_info; 829 struct nilfs_super_block **sbp; 830 int max_mnt_count; 831 int mnt_count; 832 833 /* nilfs->ns_sem must be locked by the caller. */ 834 sbp = nilfs_prepare_super(sb, 0); 835 if (!sbp) 836 return -EIO; 837 838 if (!is_mount) 839 goto skip_mount_setup; 840 841 max_mnt_count = le16_to_cpu(sbp[0]->s_max_mnt_count); 842 mnt_count = le16_to_cpu(sbp[0]->s_mnt_count); 843 844 if (nilfs->ns_mount_state & NILFS_ERROR_FS) { 845 nilfs_warn(sb, "mounting fs with errors"); 846 #if 0 847 } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) { 848 nilfs_warn(sb, "maximal mount count reached"); 849 #endif 850 } 851 if (!max_mnt_count) 852 sbp[0]->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT); 853 854 sbp[0]->s_mnt_count = cpu_to_le16(mnt_count + 1); 855 sbp[0]->s_mtime = cpu_to_le64(ktime_get_real_seconds()); 856 857 skip_mount_setup: 858 sbp[0]->s_state = 859 cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & ~NILFS_VALID_FS); 860 /* synchronize sbp[1] with sbp[0] */ 861 if (sbp[1]) 862 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 863 return nilfs_commit_super(sb, NILFS_SB_COMMIT_ALL); 864 } 865 866 struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb, 867 u64 pos, int blocksize, 868 struct buffer_head **pbh) 869 { 870 unsigned long long sb_index = pos; 871 unsigned long offset; 872 873 offset = do_div(sb_index, blocksize); 874 *pbh = sb_bread(sb, sb_index); 875 if (!*pbh) 876 return NULL; 877 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset); 878 } 879 880 int nilfs_store_magic_and_option(struct super_block *sb, 881 struct nilfs_super_block *sbp, 882 char *data) 883 { 884 struct the_nilfs *nilfs = sb->s_fs_info; 885 886 sb->s_magic = le16_to_cpu(sbp->s_magic); 887 888 /* FS independent flags */ 889 #ifdef NILFS_ATIME_DISABLE 890 sb->s_flags |= SB_NOATIME; 891 #endif 892 893 nilfs_set_default_options(sb, sbp); 894 895 nilfs->ns_resuid = le16_to_cpu(sbp->s_def_resuid); 896 nilfs->ns_resgid = le16_to_cpu(sbp->s_def_resgid); 897 nilfs->ns_interval = le32_to_cpu(sbp->s_c_interval); 898 nilfs->ns_watermark = le32_to_cpu(sbp->s_c_block_max); 899 900 return !parse_options(data, sb, 0) ? -EINVAL : 0; 901 } 902 903 int nilfs_check_feature_compatibility(struct super_block *sb, 904 struct nilfs_super_block *sbp) 905 { 906 __u64 features; 907 908 features = le64_to_cpu(sbp->s_feature_incompat) & 909 ~NILFS_FEATURE_INCOMPAT_SUPP; 910 if (features) { 911 nilfs_err(sb, 912 "couldn't mount because of unsupported optional features (%llx)", 913 (unsigned long long)features); 914 return -EINVAL; 915 } 916 features = le64_to_cpu(sbp->s_feature_compat_ro) & 917 ~NILFS_FEATURE_COMPAT_RO_SUPP; 918 if (!sb_rdonly(sb) && features) { 919 nilfs_err(sb, 920 "couldn't mount RDWR because of unsupported optional features (%llx)", 921 (unsigned long long)features); 922 return -EINVAL; 923 } 924 return 0; 925 } 926 927 static int nilfs_get_root_dentry(struct super_block *sb, 928 struct nilfs_root *root, 929 struct dentry **root_dentry) 930 { 931 struct inode *inode; 932 struct dentry *dentry; 933 int ret = 0; 934 935 inode = nilfs_iget(sb, root, NILFS_ROOT_INO); 936 if (IS_ERR(inode)) { 937 ret = PTR_ERR(inode); 938 nilfs_err(sb, "error %d getting root inode", ret); 939 goto out; 940 } 941 if (!S_ISDIR(inode->i_mode) || !inode->i_blocks || !inode->i_size) { 942 iput(inode); 943 nilfs_err(sb, "corrupt root inode"); 944 ret = -EINVAL; 945 goto out; 946 } 947 948 if (root->cno == NILFS_CPTREE_CURRENT_CNO) { 949 dentry = d_find_alias(inode); 950 if (!dentry) { 951 dentry = d_make_root(inode); 952 if (!dentry) { 953 ret = -ENOMEM; 954 goto failed_dentry; 955 } 956 } else { 957 iput(inode); 958 } 959 } else { 960 dentry = d_obtain_root(inode); 961 if (IS_ERR(dentry)) { 962 ret = PTR_ERR(dentry); 963 goto failed_dentry; 964 } 965 } 966 *root_dentry = dentry; 967 out: 968 return ret; 969 970 failed_dentry: 971 nilfs_err(sb, "error %d getting root dentry", ret); 972 goto out; 973 } 974 975 static int nilfs_attach_snapshot(struct super_block *s, __u64 cno, 976 struct dentry **root_dentry) 977 { 978 struct the_nilfs *nilfs = s->s_fs_info; 979 struct nilfs_root *root; 980 int ret; 981 982 mutex_lock(&nilfs->ns_snapshot_mount_mutex); 983 984 down_read(&nilfs->ns_segctor_sem); 985 ret = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, cno); 986 up_read(&nilfs->ns_segctor_sem); 987 if (ret < 0) { 988 ret = (ret == -ENOENT) ? -EINVAL : ret; 989 goto out; 990 } else if (!ret) { 991 nilfs_err(s, 992 "The specified checkpoint is not a snapshot (checkpoint number=%llu)", 993 (unsigned long long)cno); 994 ret = -EINVAL; 995 goto out; 996 } 997 998 ret = nilfs_attach_checkpoint(s, cno, false, &root); 999 if (ret) { 1000 nilfs_err(s, 1001 "error %d while loading snapshot (checkpoint number=%llu)", 1002 ret, (unsigned long long)cno); 1003 goto out; 1004 } 1005 ret = nilfs_get_root_dentry(s, root, root_dentry); 1006 nilfs_put_root(root); 1007 out: 1008 mutex_unlock(&nilfs->ns_snapshot_mount_mutex); 1009 return ret; 1010 } 1011 1012 /** 1013 * nilfs_tree_is_busy() - try to shrink dentries of a checkpoint 1014 * @root_dentry: root dentry of the tree to be shrunk 1015 * 1016 * This function returns true if the tree was in-use. 1017 */ 1018 static bool nilfs_tree_is_busy(struct dentry *root_dentry) 1019 { 1020 shrink_dcache_parent(root_dentry); 1021 return d_count(root_dentry) > 1; 1022 } 1023 1024 int nilfs_checkpoint_is_mounted(struct super_block *sb, __u64 cno) 1025 { 1026 struct the_nilfs *nilfs = sb->s_fs_info; 1027 struct nilfs_root *root; 1028 struct inode *inode; 1029 struct dentry *dentry; 1030 int ret; 1031 1032 if (cno > nilfs->ns_cno) 1033 return false; 1034 1035 if (cno >= nilfs_last_cno(nilfs)) 1036 return true; /* protect recent checkpoints */ 1037 1038 ret = false; 1039 root = nilfs_lookup_root(nilfs, cno); 1040 if (root) { 1041 inode = nilfs_ilookup(sb, root, NILFS_ROOT_INO); 1042 if (inode) { 1043 dentry = d_find_alias(inode); 1044 if (dentry) { 1045 ret = nilfs_tree_is_busy(dentry); 1046 dput(dentry); 1047 } 1048 iput(inode); 1049 } 1050 nilfs_put_root(root); 1051 } 1052 return ret; 1053 } 1054 1055 /** 1056 * nilfs_fill_super() - initialize a super block instance 1057 * @sb: super_block 1058 * @data: mount options 1059 * @silent: silent mode flag 1060 * 1061 * This function is called exclusively by nilfs->ns_mount_mutex. 1062 * So, the recovery process is protected from other simultaneous mounts. 1063 */ 1064 static int 1065 nilfs_fill_super(struct super_block *sb, void *data, int silent) 1066 { 1067 struct the_nilfs *nilfs; 1068 struct nilfs_root *fsroot; 1069 __u64 cno; 1070 int err; 1071 1072 nilfs = alloc_nilfs(sb); 1073 if (!nilfs) 1074 return -ENOMEM; 1075 1076 sb->s_fs_info = nilfs; 1077 1078 err = init_nilfs(nilfs, sb, (char *)data); 1079 if (err) 1080 goto failed_nilfs; 1081 1082 sb->s_op = &nilfs_sops; 1083 sb->s_export_op = &nilfs_export_ops; 1084 sb->s_root = NULL; 1085 sb->s_time_gran = 1; 1086 sb->s_max_links = NILFS_LINK_MAX; 1087 1088 sb->s_bdi = bdi_get(sb->s_bdev->bd_disk->bdi); 1089 1090 err = load_nilfs(nilfs, sb); 1091 if (err) 1092 goto failed_nilfs; 1093 1094 cno = nilfs_last_cno(nilfs); 1095 err = nilfs_attach_checkpoint(sb, cno, true, &fsroot); 1096 if (err) { 1097 nilfs_err(sb, 1098 "error %d while loading last checkpoint (checkpoint number=%llu)", 1099 err, (unsigned long long)cno); 1100 goto failed_unload; 1101 } 1102 1103 if (!sb_rdonly(sb)) { 1104 err = nilfs_attach_log_writer(sb, fsroot); 1105 if (err) 1106 goto failed_checkpoint; 1107 } 1108 1109 err = nilfs_get_root_dentry(sb, fsroot, &sb->s_root); 1110 if (err) 1111 goto failed_segctor; 1112 1113 nilfs_put_root(fsroot); 1114 1115 if (!sb_rdonly(sb)) { 1116 down_write(&nilfs->ns_sem); 1117 nilfs_setup_super(sb, true); 1118 up_write(&nilfs->ns_sem); 1119 } 1120 1121 return 0; 1122 1123 failed_segctor: 1124 nilfs_detach_log_writer(sb); 1125 1126 failed_checkpoint: 1127 nilfs_put_root(fsroot); 1128 1129 failed_unload: 1130 nilfs_sysfs_delete_device_group(nilfs); 1131 iput(nilfs->ns_sufile); 1132 iput(nilfs->ns_cpfile); 1133 iput(nilfs->ns_dat); 1134 1135 failed_nilfs: 1136 destroy_nilfs(nilfs); 1137 return err; 1138 } 1139 1140 static int nilfs_remount(struct super_block *sb, int *flags, char *data) 1141 { 1142 struct the_nilfs *nilfs = sb->s_fs_info; 1143 unsigned long old_sb_flags; 1144 unsigned long old_mount_opt; 1145 int err; 1146 1147 sync_filesystem(sb); 1148 old_sb_flags = sb->s_flags; 1149 old_mount_opt = nilfs->ns_mount_opt; 1150 1151 if (!parse_options(data, sb, 1)) { 1152 err = -EINVAL; 1153 goto restore_opts; 1154 } 1155 sb->s_flags = (sb->s_flags & ~SB_POSIXACL); 1156 1157 err = -EINVAL; 1158 1159 if (!nilfs_valid_fs(nilfs)) { 1160 nilfs_warn(sb, 1161 "couldn't remount because the filesystem is in an incomplete recovery state"); 1162 goto restore_opts; 1163 } 1164 1165 if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb)) 1166 goto out; 1167 if (*flags & SB_RDONLY) { 1168 sb->s_flags |= SB_RDONLY; 1169 1170 /* 1171 * Remounting a valid RW partition RDONLY, so set 1172 * the RDONLY flag and then mark the partition as valid again. 1173 */ 1174 down_write(&nilfs->ns_sem); 1175 nilfs_cleanup_super(sb); 1176 up_write(&nilfs->ns_sem); 1177 } else { 1178 __u64 features; 1179 struct nilfs_root *root; 1180 1181 /* 1182 * Mounting a RDONLY partition read-write, so reread and 1183 * store the current valid flag. (It may have been changed 1184 * by fsck since we originally mounted the partition.) 1185 */ 1186 down_read(&nilfs->ns_sem); 1187 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & 1188 ~NILFS_FEATURE_COMPAT_RO_SUPP; 1189 up_read(&nilfs->ns_sem); 1190 if (features) { 1191 nilfs_warn(sb, 1192 "couldn't remount RDWR because of unsupported optional features (%llx)", 1193 (unsigned long long)features); 1194 err = -EROFS; 1195 goto restore_opts; 1196 } 1197 1198 sb->s_flags &= ~SB_RDONLY; 1199 1200 root = NILFS_I(d_inode(sb->s_root))->i_root; 1201 err = nilfs_attach_log_writer(sb, root); 1202 if (err) 1203 goto restore_opts; 1204 1205 down_write(&nilfs->ns_sem); 1206 nilfs_setup_super(sb, true); 1207 up_write(&nilfs->ns_sem); 1208 } 1209 out: 1210 return 0; 1211 1212 restore_opts: 1213 sb->s_flags = old_sb_flags; 1214 nilfs->ns_mount_opt = old_mount_opt; 1215 return err; 1216 } 1217 1218 struct nilfs_super_data { 1219 struct block_device *bdev; 1220 __u64 cno; 1221 int flags; 1222 }; 1223 1224 static int nilfs_parse_snapshot_option(const char *option, 1225 const substring_t *arg, 1226 struct nilfs_super_data *sd) 1227 { 1228 unsigned long long val; 1229 const char *msg = NULL; 1230 int err; 1231 1232 if (!(sd->flags & SB_RDONLY)) { 1233 msg = "read-only option is not specified"; 1234 goto parse_error; 1235 } 1236 1237 err = kstrtoull(arg->from, 0, &val); 1238 if (err) { 1239 if (err == -ERANGE) 1240 msg = "too large checkpoint number"; 1241 else 1242 msg = "malformed argument"; 1243 goto parse_error; 1244 } else if (val == 0) { 1245 msg = "invalid checkpoint number 0"; 1246 goto parse_error; 1247 } 1248 sd->cno = val; 1249 return 0; 1250 1251 parse_error: 1252 nilfs_err(NULL, "invalid option \"%s\": %s", option, msg); 1253 return 1; 1254 } 1255 1256 /** 1257 * nilfs_identify - pre-read mount options needed to identify mount instance 1258 * @data: mount options 1259 * @sd: nilfs_super_data 1260 */ 1261 static int nilfs_identify(char *data, struct nilfs_super_data *sd) 1262 { 1263 char *p, *options = data; 1264 substring_t args[MAX_OPT_ARGS]; 1265 int token; 1266 int ret = 0; 1267 1268 do { 1269 p = strsep(&options, ","); 1270 if (p != NULL && *p) { 1271 token = match_token(p, tokens, args); 1272 if (token == Opt_snapshot) 1273 ret = nilfs_parse_snapshot_option(p, &args[0], 1274 sd); 1275 } 1276 if (!options) 1277 break; 1278 BUG_ON(options == data); 1279 *(options - 1) = ','; 1280 } while (!ret); 1281 return ret; 1282 } 1283 1284 static int nilfs_set_bdev_super(struct super_block *s, void *data) 1285 { 1286 s->s_bdev = data; 1287 s->s_dev = s->s_bdev->bd_dev; 1288 return 0; 1289 } 1290 1291 static int nilfs_test_bdev_super(struct super_block *s, void *data) 1292 { 1293 return (void *)s->s_bdev == data; 1294 } 1295 1296 static struct dentry * 1297 nilfs_mount(struct file_system_type *fs_type, int flags, 1298 const char *dev_name, void *data) 1299 { 1300 struct nilfs_super_data sd; 1301 struct super_block *s; 1302 struct dentry *root_dentry; 1303 int err, s_new = false; 1304 1305 sd.bdev = blkdev_get_by_path(dev_name, sb_open_mode(flags), fs_type, 1306 NULL); 1307 if (IS_ERR(sd.bdev)) 1308 return ERR_CAST(sd.bdev); 1309 1310 sd.cno = 0; 1311 sd.flags = flags; 1312 if (nilfs_identify((char *)data, &sd)) { 1313 err = -EINVAL; 1314 goto failed; 1315 } 1316 1317 /* 1318 * once the super is inserted into the list by sget, s_umount 1319 * will protect the lockfs code from trying to start a snapshot 1320 * while we are mounting 1321 */ 1322 mutex_lock(&sd.bdev->bd_fsfreeze_mutex); 1323 if (sd.bdev->bd_fsfreeze_count > 0) { 1324 mutex_unlock(&sd.bdev->bd_fsfreeze_mutex); 1325 err = -EBUSY; 1326 goto failed; 1327 } 1328 s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, flags, 1329 sd.bdev); 1330 mutex_unlock(&sd.bdev->bd_fsfreeze_mutex); 1331 if (IS_ERR(s)) { 1332 err = PTR_ERR(s); 1333 goto failed; 1334 } 1335 1336 if (!s->s_root) { 1337 s_new = true; 1338 1339 /* New superblock instance created */ 1340 snprintf(s->s_id, sizeof(s->s_id), "%pg", sd.bdev); 1341 sb_set_blocksize(s, block_size(sd.bdev)); 1342 1343 err = nilfs_fill_super(s, data, flags & SB_SILENT ? 1 : 0); 1344 if (err) 1345 goto failed_super; 1346 1347 s->s_flags |= SB_ACTIVE; 1348 } else if (!sd.cno) { 1349 if (nilfs_tree_is_busy(s->s_root)) { 1350 if ((flags ^ s->s_flags) & SB_RDONLY) { 1351 nilfs_err(s, 1352 "the device already has a %s mount.", 1353 sb_rdonly(s) ? "read-only" : "read/write"); 1354 err = -EBUSY; 1355 goto failed_super; 1356 } 1357 } else { 1358 /* 1359 * Try remount to setup mount states if the current 1360 * tree is not mounted and only snapshots use this sb. 1361 */ 1362 err = nilfs_remount(s, &flags, data); 1363 if (err) 1364 goto failed_super; 1365 } 1366 } 1367 1368 if (sd.cno) { 1369 err = nilfs_attach_snapshot(s, sd.cno, &root_dentry); 1370 if (err) 1371 goto failed_super; 1372 } else { 1373 root_dentry = dget(s->s_root); 1374 } 1375 1376 if (!s_new) 1377 blkdev_put(sd.bdev, fs_type); 1378 1379 return root_dentry; 1380 1381 failed_super: 1382 deactivate_locked_super(s); 1383 1384 failed: 1385 if (!s_new) 1386 blkdev_put(sd.bdev, fs_type); 1387 return ERR_PTR(err); 1388 } 1389 1390 struct file_system_type nilfs_fs_type = { 1391 .owner = THIS_MODULE, 1392 .name = "nilfs2", 1393 .mount = nilfs_mount, 1394 .kill_sb = kill_block_super, 1395 .fs_flags = FS_REQUIRES_DEV, 1396 }; 1397 MODULE_ALIAS_FS("nilfs2"); 1398 1399 static void nilfs_inode_init_once(void *obj) 1400 { 1401 struct nilfs_inode_info *ii = obj; 1402 1403 INIT_LIST_HEAD(&ii->i_dirty); 1404 #ifdef CONFIG_NILFS_XATTR 1405 init_rwsem(&ii->xattr_sem); 1406 #endif 1407 inode_init_once(&ii->vfs_inode); 1408 } 1409 1410 static void nilfs_segbuf_init_once(void *obj) 1411 { 1412 memset(obj, 0, sizeof(struct nilfs_segment_buffer)); 1413 } 1414 1415 static void nilfs_destroy_cachep(void) 1416 { 1417 /* 1418 * Make sure all delayed rcu free inodes are flushed before we 1419 * destroy cache. 1420 */ 1421 rcu_barrier(); 1422 1423 kmem_cache_destroy(nilfs_inode_cachep); 1424 kmem_cache_destroy(nilfs_transaction_cachep); 1425 kmem_cache_destroy(nilfs_segbuf_cachep); 1426 kmem_cache_destroy(nilfs_btree_path_cache); 1427 } 1428 1429 static int __init nilfs_init_cachep(void) 1430 { 1431 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", 1432 sizeof(struct nilfs_inode_info), 0, 1433 SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, 1434 nilfs_inode_init_once); 1435 if (!nilfs_inode_cachep) 1436 goto fail; 1437 1438 nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache", 1439 sizeof(struct nilfs_transaction_info), 0, 1440 SLAB_RECLAIM_ACCOUNT, NULL); 1441 if (!nilfs_transaction_cachep) 1442 goto fail; 1443 1444 nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache", 1445 sizeof(struct nilfs_segment_buffer), 0, 1446 SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once); 1447 if (!nilfs_segbuf_cachep) 1448 goto fail; 1449 1450 nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache", 1451 sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX, 1452 0, 0, NULL); 1453 if (!nilfs_btree_path_cache) 1454 goto fail; 1455 1456 return 0; 1457 1458 fail: 1459 nilfs_destroy_cachep(); 1460 return -ENOMEM; 1461 } 1462 1463 static int __init init_nilfs_fs(void) 1464 { 1465 int err; 1466 1467 err = nilfs_init_cachep(); 1468 if (err) 1469 goto fail; 1470 1471 err = nilfs_sysfs_init(); 1472 if (err) 1473 goto free_cachep; 1474 1475 err = register_filesystem(&nilfs_fs_type); 1476 if (err) 1477 goto deinit_sysfs_entry; 1478 1479 printk(KERN_INFO "NILFS version 2 loaded\n"); 1480 return 0; 1481 1482 deinit_sysfs_entry: 1483 nilfs_sysfs_exit(); 1484 free_cachep: 1485 nilfs_destroy_cachep(); 1486 fail: 1487 return err; 1488 } 1489 1490 static void __exit exit_nilfs_fs(void) 1491 { 1492 nilfs_destroy_cachep(); 1493 nilfs_sysfs_exit(); 1494 unregister_filesystem(&nilfs_fs_type); 1495 } 1496 1497 module_init(init_nilfs_fs) 1498 module_exit(exit_nilfs_fs) 1499