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/crc32.h> 47 #include <linux/vfs.h> 48 #include <linux/writeback.h> 49 #include <linux/seq_file.h> 50 #include <linux/mount.h> 51 #include "nilfs.h" 52 #include "export.h" 53 #include "mdt.h" 54 #include "alloc.h" 55 #include "btree.h" 56 #include "btnode.h" 57 #include "page.h" 58 #include "cpfile.h" 59 #include "sufile.h" /* nilfs_sufile_resize(), nilfs_sufile_set_alloc_range() */ 60 #include "ifile.h" 61 #include "dat.h" 62 #include "segment.h" 63 #include "segbuf.h" 64 65 MODULE_AUTHOR("NTT Corp."); 66 MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem " 67 "(NILFS)"); 68 MODULE_LICENSE("GPL"); 69 70 static struct kmem_cache *nilfs_inode_cachep; 71 struct kmem_cache *nilfs_transaction_cachep; 72 struct kmem_cache *nilfs_segbuf_cachep; 73 struct kmem_cache *nilfs_btree_path_cache; 74 75 static int nilfs_setup_super(struct super_block *sb, int is_mount); 76 static int nilfs_remount(struct super_block *sb, int *flags, char *data); 77 78 static void nilfs_set_error(struct super_block *sb) 79 { 80 struct the_nilfs *nilfs = sb->s_fs_info; 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(sb, 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(sb, 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 the_nilfs *nilfs = sb->s_fs_info; 113 struct va_format vaf; 114 va_list args; 115 116 va_start(args, fmt); 117 118 vaf.fmt = fmt; 119 vaf.va = &args; 120 121 printk(KERN_CRIT "NILFS error (device %s): %s: %pV\n", 122 sb->s_id, function, &vaf); 123 124 va_end(args); 125 126 if (!(sb->s_flags & MS_RDONLY)) { 127 nilfs_set_error(sb); 128 129 if (nilfs_test_opt(nilfs, ERRORS_RO)) { 130 printk(KERN_CRIT "Remounting filesystem read-only\n"); 131 sb->s_flags |= MS_RDONLY; 132 } 133 } 134 135 if (nilfs_test_opt(nilfs, ERRORS_PANIC)) 136 panic("NILFS (device %s): panic forced after error\n", 137 sb->s_id); 138 } 139 140 void nilfs_warning(struct super_block *sb, const char *function, 141 const char *fmt, ...) 142 { 143 struct va_format vaf; 144 va_list args; 145 146 va_start(args, fmt); 147 148 vaf.fmt = fmt; 149 vaf.va = &args; 150 151 printk(KERN_WARNING "NILFS warning (device %s): %s: %pV\n", 152 sb->s_id, function, &vaf); 153 154 va_end(args); 155 } 156 157 158 struct inode *nilfs_alloc_inode(struct super_block *sb) 159 { 160 struct nilfs_inode_info *ii; 161 162 ii = kmem_cache_alloc(nilfs_inode_cachep, GFP_NOFS); 163 if (!ii) 164 return NULL; 165 ii->i_bh = NULL; 166 ii->i_state = 0; 167 ii->i_cno = 0; 168 ii->vfs_inode.i_version = 1; 169 nilfs_mapping_init(&ii->i_btnode_cache, &ii->vfs_inode, sb->s_bdi); 170 return &ii->vfs_inode; 171 } 172 173 static void nilfs_i_callback(struct rcu_head *head) 174 { 175 struct inode *inode = container_of(head, struct inode, i_rcu); 176 struct nilfs_mdt_info *mdi = NILFS_MDT(inode); 177 178 if (mdi) { 179 kfree(mdi->mi_bgl); /* kfree(NULL) is safe */ 180 kfree(mdi); 181 } 182 kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode)); 183 } 184 185 void nilfs_destroy_inode(struct inode *inode) 186 { 187 call_rcu(&inode->i_rcu, nilfs_i_callback); 188 } 189 190 static int nilfs_sync_super(struct super_block *sb, int flag) 191 { 192 struct the_nilfs *nilfs = sb->s_fs_info; 193 int err; 194 195 retry: 196 set_buffer_dirty(nilfs->ns_sbh[0]); 197 if (nilfs_test_opt(nilfs, BARRIER)) { 198 err = __sync_dirty_buffer(nilfs->ns_sbh[0], 199 WRITE_SYNC | WRITE_FLUSH_FUA); 200 } else { 201 err = sync_dirty_buffer(nilfs->ns_sbh[0]); 202 } 203 204 if (unlikely(err)) { 205 printk(KERN_ERR 206 "NILFS: unable to write superblock (err=%d)\n", err); 207 if (err == -EIO && nilfs->ns_sbh[1]) { 208 /* 209 * sbp[0] points to newer log than sbp[1], 210 * so copy sbp[0] to sbp[1] to take over sbp[0]. 211 */ 212 memcpy(nilfs->ns_sbp[1], nilfs->ns_sbp[0], 213 nilfs->ns_sbsize); 214 nilfs_fall_back_super_block(nilfs); 215 goto retry; 216 } 217 } else { 218 struct nilfs_super_block *sbp = nilfs->ns_sbp[0]; 219 220 nilfs->ns_sbwcount++; 221 222 /* 223 * The latest segment becomes trailable from the position 224 * written in superblock. 225 */ 226 clear_nilfs_discontinued(nilfs); 227 228 /* update GC protection for recent segments */ 229 if (nilfs->ns_sbh[1]) { 230 if (flag == NILFS_SB_COMMIT_ALL) { 231 set_buffer_dirty(nilfs->ns_sbh[1]); 232 if (sync_dirty_buffer(nilfs->ns_sbh[1]) < 0) 233 goto out; 234 } 235 if (le64_to_cpu(nilfs->ns_sbp[1]->s_last_cno) < 236 le64_to_cpu(nilfs->ns_sbp[0]->s_last_cno)) 237 sbp = nilfs->ns_sbp[1]; 238 } 239 240 spin_lock(&nilfs->ns_last_segment_lock); 241 nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq); 242 spin_unlock(&nilfs->ns_last_segment_lock); 243 } 244 out: 245 return err; 246 } 247 248 void nilfs_set_log_cursor(struct nilfs_super_block *sbp, 249 struct the_nilfs *nilfs) 250 { 251 sector_t nfreeblocks; 252 253 /* nilfs->ns_sem must be locked by the caller. */ 254 nilfs_count_free_blocks(nilfs, &nfreeblocks); 255 sbp->s_free_blocks_count = cpu_to_le64(nfreeblocks); 256 257 spin_lock(&nilfs->ns_last_segment_lock); 258 sbp->s_last_seq = cpu_to_le64(nilfs->ns_last_seq); 259 sbp->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg); 260 sbp->s_last_cno = cpu_to_le64(nilfs->ns_last_cno); 261 spin_unlock(&nilfs->ns_last_segment_lock); 262 } 263 264 struct nilfs_super_block **nilfs_prepare_super(struct super_block *sb, 265 int flip) 266 { 267 struct the_nilfs *nilfs = sb->s_fs_info; 268 struct nilfs_super_block **sbp = nilfs->ns_sbp; 269 270 /* nilfs->ns_sem must be locked by the caller. */ 271 if (sbp[0]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 272 if (sbp[1] && 273 sbp[1]->s_magic == cpu_to_le16(NILFS_SUPER_MAGIC)) { 274 memcpy(sbp[0], sbp[1], nilfs->ns_sbsize); 275 } else { 276 printk(KERN_CRIT "NILFS: superblock broke on dev %s\n", 277 sb->s_id); 278 return NULL; 279 } 280 } else if (sbp[1] && 281 sbp[1]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 282 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 283 } 284 285 if (flip && sbp[1]) 286 nilfs_swap_super_block(nilfs); 287 288 return sbp; 289 } 290 291 int nilfs_commit_super(struct super_block *sb, int flag) 292 { 293 struct the_nilfs *nilfs = sb->s_fs_info; 294 struct nilfs_super_block **sbp = nilfs->ns_sbp; 295 time_t t; 296 297 /* nilfs->ns_sem must be locked by the caller. */ 298 t = get_seconds(); 299 nilfs->ns_sbwtime = t; 300 sbp[0]->s_wtime = cpu_to_le64(t); 301 sbp[0]->s_sum = 0; 302 sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 303 (unsigned char *)sbp[0], 304 nilfs->ns_sbsize)); 305 if (flag == NILFS_SB_COMMIT_ALL && sbp[1]) { 306 sbp[1]->s_wtime = sbp[0]->s_wtime; 307 sbp[1]->s_sum = 0; 308 sbp[1]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 309 (unsigned char *)sbp[1], 310 nilfs->ns_sbsize)); 311 } 312 clear_nilfs_sb_dirty(nilfs); 313 return nilfs_sync_super(sb, flag); 314 } 315 316 /** 317 * nilfs_cleanup_super() - write filesystem state for cleanup 318 * @sb: super block instance to be unmounted or degraded to read-only 319 * 320 * This function restores state flags in the on-disk super block. 321 * This will set "clean" flag (i.e. NILFS_VALID_FS) unless the 322 * filesystem was not clean previously. 323 */ 324 int nilfs_cleanup_super(struct super_block *sb) 325 { 326 struct the_nilfs *nilfs = sb->s_fs_info; 327 struct nilfs_super_block **sbp; 328 int flag = NILFS_SB_COMMIT; 329 int ret = -EIO; 330 331 sbp = nilfs_prepare_super(sb, 0); 332 if (sbp) { 333 sbp[0]->s_state = cpu_to_le16(nilfs->ns_mount_state); 334 nilfs_set_log_cursor(sbp[0], nilfs); 335 if (sbp[1] && sbp[0]->s_last_cno == sbp[1]->s_last_cno) { 336 /* 337 * make the "clean" flag also to the opposite 338 * super block if both super blocks point to 339 * the same checkpoint. 340 */ 341 sbp[1]->s_state = sbp[0]->s_state; 342 flag = NILFS_SB_COMMIT_ALL; 343 } 344 ret = nilfs_commit_super(sb, flag); 345 } 346 return ret; 347 } 348 349 /** 350 * nilfs_move_2nd_super - relocate secondary super block 351 * @sb: super block instance 352 * @sb2off: new offset of the secondary super block (in bytes) 353 */ 354 static int nilfs_move_2nd_super(struct super_block *sb, loff_t sb2off) 355 { 356 struct the_nilfs *nilfs = sb->s_fs_info; 357 struct buffer_head *nsbh; 358 struct nilfs_super_block *nsbp; 359 sector_t blocknr, newblocknr; 360 unsigned long offset; 361 int sb2i = -1; /* array index of the secondary superblock */ 362 int ret = 0; 363 364 /* nilfs->ns_sem must be locked by the caller. */ 365 if (nilfs->ns_sbh[1] && 366 nilfs->ns_sbh[1]->b_blocknr > nilfs->ns_first_data_block) { 367 sb2i = 1; 368 blocknr = nilfs->ns_sbh[1]->b_blocknr; 369 } else if (nilfs->ns_sbh[0]->b_blocknr > nilfs->ns_first_data_block) { 370 sb2i = 0; 371 blocknr = nilfs->ns_sbh[0]->b_blocknr; 372 } 373 if (sb2i >= 0 && (u64)blocknr << nilfs->ns_blocksize_bits == sb2off) 374 goto out; /* super block location is unchanged */ 375 376 /* Get new super block buffer */ 377 newblocknr = sb2off >> nilfs->ns_blocksize_bits; 378 offset = sb2off & (nilfs->ns_blocksize - 1); 379 nsbh = sb_getblk(sb, newblocknr); 380 if (!nsbh) { 381 printk(KERN_WARNING 382 "NILFS warning: unable to move secondary superblock " 383 "to block %llu\n", (unsigned long long)newblocknr); 384 ret = -EIO; 385 goto out; 386 } 387 nsbp = (void *)nsbh->b_data + offset; 388 memset(nsbp, 0, nilfs->ns_blocksize); 389 390 if (sb2i >= 0) { 391 memcpy(nsbp, nilfs->ns_sbp[sb2i], nilfs->ns_sbsize); 392 brelse(nilfs->ns_sbh[sb2i]); 393 nilfs->ns_sbh[sb2i] = nsbh; 394 nilfs->ns_sbp[sb2i] = nsbp; 395 } else if (nilfs->ns_sbh[0]->b_blocknr < nilfs->ns_first_data_block) { 396 /* secondary super block will be restored to index 1 */ 397 nilfs->ns_sbh[1] = nsbh; 398 nilfs->ns_sbp[1] = nsbp; 399 } else { 400 brelse(nsbh); 401 } 402 out: 403 return ret; 404 } 405 406 /** 407 * nilfs_resize_fs - resize the filesystem 408 * @sb: super block instance 409 * @newsize: new size of the filesystem (in bytes) 410 */ 411 int nilfs_resize_fs(struct super_block *sb, __u64 newsize) 412 { 413 struct the_nilfs *nilfs = sb->s_fs_info; 414 struct nilfs_super_block **sbp; 415 __u64 devsize, newnsegs; 416 loff_t sb2off; 417 int ret; 418 419 ret = -ERANGE; 420 devsize = i_size_read(sb->s_bdev->bd_inode); 421 if (newsize > devsize) 422 goto out; 423 424 /* 425 * Write lock is required to protect some functions depending 426 * on the number of segments, the number of reserved segments, 427 * and so forth. 428 */ 429 down_write(&nilfs->ns_segctor_sem); 430 431 sb2off = NILFS_SB2_OFFSET_BYTES(newsize); 432 newnsegs = sb2off >> nilfs->ns_blocksize_bits; 433 do_div(newnsegs, nilfs->ns_blocks_per_segment); 434 435 ret = nilfs_sufile_resize(nilfs->ns_sufile, newnsegs); 436 up_write(&nilfs->ns_segctor_sem); 437 if (ret < 0) 438 goto out; 439 440 ret = nilfs_construct_segment(sb); 441 if (ret < 0) 442 goto out; 443 444 down_write(&nilfs->ns_sem); 445 nilfs_move_2nd_super(sb, sb2off); 446 ret = -EIO; 447 sbp = nilfs_prepare_super(sb, 0); 448 if (likely(sbp)) { 449 nilfs_set_log_cursor(sbp[0], nilfs); 450 /* 451 * Drop NILFS_RESIZE_FS flag for compatibility with 452 * mount-time resize which may be implemented in a 453 * future release. 454 */ 455 sbp[0]->s_state = cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & 456 ~NILFS_RESIZE_FS); 457 sbp[0]->s_dev_size = cpu_to_le64(newsize); 458 sbp[0]->s_nsegments = cpu_to_le64(nilfs->ns_nsegments); 459 if (sbp[1]) 460 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 461 ret = nilfs_commit_super(sb, NILFS_SB_COMMIT_ALL); 462 } 463 up_write(&nilfs->ns_sem); 464 465 /* 466 * Reset the range of allocatable segments last. This order 467 * is important in the case of expansion because the secondary 468 * superblock must be protected from log write until migration 469 * completes. 470 */ 471 if (!ret) 472 nilfs_sufile_set_alloc_range(nilfs->ns_sufile, 0, newnsegs - 1); 473 out: 474 return ret; 475 } 476 477 static void nilfs_put_super(struct super_block *sb) 478 { 479 struct the_nilfs *nilfs = sb->s_fs_info; 480 481 nilfs_detach_log_writer(sb); 482 483 if (!(sb->s_flags & MS_RDONLY)) { 484 down_write(&nilfs->ns_sem); 485 nilfs_cleanup_super(sb); 486 up_write(&nilfs->ns_sem); 487 } 488 489 iput(nilfs->ns_sufile); 490 iput(nilfs->ns_cpfile); 491 iput(nilfs->ns_dat); 492 493 destroy_nilfs(nilfs); 494 sb->s_fs_info = NULL; 495 } 496 497 static int nilfs_sync_fs(struct super_block *sb, int wait) 498 { 499 struct the_nilfs *nilfs = sb->s_fs_info; 500 struct nilfs_super_block **sbp; 501 int err = 0; 502 503 /* This function is called when super block should be written back */ 504 if (wait) 505 err = nilfs_construct_segment(sb); 506 507 down_write(&nilfs->ns_sem); 508 if (nilfs_sb_dirty(nilfs)) { 509 sbp = nilfs_prepare_super(sb, nilfs_sb_will_flip(nilfs)); 510 if (likely(sbp)) { 511 nilfs_set_log_cursor(sbp[0], nilfs); 512 nilfs_commit_super(sb, NILFS_SB_COMMIT); 513 } 514 } 515 up_write(&nilfs->ns_sem); 516 517 return err; 518 } 519 520 int nilfs_attach_checkpoint(struct super_block *sb, __u64 cno, int curr_mnt, 521 struct nilfs_root **rootp) 522 { 523 struct the_nilfs *nilfs = sb->s_fs_info; 524 struct nilfs_root *root; 525 struct nilfs_checkpoint *raw_cp; 526 struct buffer_head *bh_cp; 527 int err = -ENOMEM; 528 529 root = nilfs_find_or_create_root( 530 nilfs, curr_mnt ? NILFS_CPTREE_CURRENT_CNO : cno); 531 if (!root) 532 return err; 533 534 if (root->ifile) 535 goto reuse; /* already attached checkpoint */ 536 537 down_read(&nilfs->ns_segctor_sem); 538 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp, 539 &bh_cp); 540 up_read(&nilfs->ns_segctor_sem); 541 if (unlikely(err)) { 542 if (err == -ENOENT || err == -EINVAL) { 543 printk(KERN_ERR 544 "NILFS: Invalid checkpoint " 545 "(checkpoint number=%llu)\n", 546 (unsigned long long)cno); 547 err = -EINVAL; 548 } 549 goto failed; 550 } 551 552 err = nilfs_ifile_read(sb, root, nilfs->ns_inode_size, 553 &raw_cp->cp_ifile_inode, &root->ifile); 554 if (err) 555 goto failed_bh; 556 557 atomic64_set(&root->inodes_count, 558 le64_to_cpu(raw_cp->cp_inodes_count)); 559 atomic64_set(&root->blocks_count, 560 le64_to_cpu(raw_cp->cp_blocks_count)); 561 562 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 563 564 reuse: 565 *rootp = root; 566 return 0; 567 568 failed_bh: 569 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 570 failed: 571 nilfs_put_root(root); 572 573 return err; 574 } 575 576 static int nilfs_freeze(struct super_block *sb) 577 { 578 struct the_nilfs *nilfs = sb->s_fs_info; 579 int err; 580 581 if (sb->s_flags & MS_RDONLY) 582 return 0; 583 584 /* Mark super block clean */ 585 down_write(&nilfs->ns_sem); 586 err = nilfs_cleanup_super(sb); 587 up_write(&nilfs->ns_sem); 588 return err; 589 } 590 591 static int nilfs_unfreeze(struct super_block *sb) 592 { 593 struct the_nilfs *nilfs = sb->s_fs_info; 594 595 if (sb->s_flags & MS_RDONLY) 596 return 0; 597 598 down_write(&nilfs->ns_sem); 599 nilfs_setup_super(sb, false); 600 up_write(&nilfs->ns_sem); 601 return 0; 602 } 603 604 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 605 { 606 struct super_block *sb = dentry->d_sb; 607 struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root; 608 struct the_nilfs *nilfs = root->nilfs; 609 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 610 unsigned long long blocks; 611 unsigned long overhead; 612 unsigned long nrsvblocks; 613 sector_t nfreeblocks; 614 u64 nmaxinodes, nfreeinodes; 615 int err; 616 617 /* 618 * Compute all of the segment blocks 619 * 620 * The blocks before first segment and after last segment 621 * are excluded. 622 */ 623 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments 624 - nilfs->ns_first_data_block; 625 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment; 626 627 /* 628 * Compute the overhead 629 * 630 * When distributing meta data blocks outside segment structure, 631 * We must count them as the overhead. 632 */ 633 overhead = 0; 634 635 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 636 if (unlikely(err)) 637 return err; 638 639 err = nilfs_ifile_count_free_inodes(root->ifile, 640 &nmaxinodes, &nfreeinodes); 641 if (unlikely(err)) { 642 printk(KERN_WARNING 643 "NILFS warning: fail to count free inodes: err %d.\n", 644 err); 645 if (err == -ERANGE) { 646 /* 647 * If nilfs_palloc_count_max_entries() returns 648 * -ERANGE error code then we simply treat 649 * curent inodes count as maximum possible and 650 * zero as free inodes value. 651 */ 652 nmaxinodes = atomic64_read(&root->inodes_count); 653 nfreeinodes = 0; 654 err = 0; 655 } else 656 return err; 657 } 658 659 buf->f_type = NILFS_SUPER_MAGIC; 660 buf->f_bsize = sb->s_blocksize; 661 buf->f_blocks = blocks - overhead; 662 buf->f_bfree = nfreeblocks; 663 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? 664 (buf->f_bfree - nrsvblocks) : 0; 665 buf->f_files = nmaxinodes; 666 buf->f_ffree = nfreeinodes; 667 buf->f_namelen = NILFS_NAME_LEN; 668 buf->f_fsid.val[0] = (u32)id; 669 buf->f_fsid.val[1] = (u32)(id >> 32); 670 671 return 0; 672 } 673 674 static int nilfs_show_options(struct seq_file *seq, struct dentry *dentry) 675 { 676 struct super_block *sb = dentry->d_sb; 677 struct the_nilfs *nilfs = sb->s_fs_info; 678 struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root; 679 680 if (!nilfs_test_opt(nilfs, BARRIER)) 681 seq_puts(seq, ",nobarrier"); 682 if (root->cno != NILFS_CPTREE_CURRENT_CNO) 683 seq_printf(seq, ",cp=%llu", (unsigned long long)root->cno); 684 if (nilfs_test_opt(nilfs, ERRORS_PANIC)) 685 seq_puts(seq, ",errors=panic"); 686 if (nilfs_test_opt(nilfs, ERRORS_CONT)) 687 seq_puts(seq, ",errors=continue"); 688 if (nilfs_test_opt(nilfs, STRICT_ORDER)) 689 seq_puts(seq, ",order=strict"); 690 if (nilfs_test_opt(nilfs, NORECOVERY)) 691 seq_puts(seq, ",norecovery"); 692 if (nilfs_test_opt(nilfs, DISCARD)) 693 seq_puts(seq, ",discard"); 694 695 return 0; 696 } 697 698 static const struct super_operations nilfs_sops = { 699 .alloc_inode = nilfs_alloc_inode, 700 .destroy_inode = nilfs_destroy_inode, 701 .dirty_inode = nilfs_dirty_inode, 702 .evict_inode = nilfs_evict_inode, 703 .put_super = nilfs_put_super, 704 .sync_fs = nilfs_sync_fs, 705 .freeze_fs = nilfs_freeze, 706 .unfreeze_fs = nilfs_unfreeze, 707 .statfs = nilfs_statfs, 708 .remount_fs = nilfs_remount, 709 .show_options = nilfs_show_options 710 }; 711 712 enum { 713 Opt_err_cont, Opt_err_panic, Opt_err_ro, 714 Opt_barrier, Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery, 715 Opt_discard, Opt_nodiscard, Opt_err, 716 }; 717 718 static match_table_t tokens = { 719 {Opt_err_cont, "errors=continue"}, 720 {Opt_err_panic, "errors=panic"}, 721 {Opt_err_ro, "errors=remount-ro"}, 722 {Opt_barrier, "barrier"}, 723 {Opt_nobarrier, "nobarrier"}, 724 {Opt_snapshot, "cp=%u"}, 725 {Opt_order, "order=%s"}, 726 {Opt_norecovery, "norecovery"}, 727 {Opt_discard, "discard"}, 728 {Opt_nodiscard, "nodiscard"}, 729 {Opt_err, NULL} 730 }; 731 732 static int parse_options(char *options, struct super_block *sb, int is_remount) 733 { 734 struct the_nilfs *nilfs = sb->s_fs_info; 735 char *p; 736 substring_t args[MAX_OPT_ARGS]; 737 738 if (!options) 739 return 1; 740 741 while ((p = strsep(&options, ",")) != NULL) { 742 int token; 743 if (!*p) 744 continue; 745 746 token = match_token(p, tokens, args); 747 switch (token) { 748 case Opt_barrier: 749 nilfs_set_opt(nilfs, BARRIER); 750 break; 751 case Opt_nobarrier: 752 nilfs_clear_opt(nilfs, BARRIER); 753 break; 754 case Opt_order: 755 if (strcmp(args[0].from, "relaxed") == 0) 756 /* Ordered data semantics */ 757 nilfs_clear_opt(nilfs, STRICT_ORDER); 758 else if (strcmp(args[0].from, "strict") == 0) 759 /* Strict in-order semantics */ 760 nilfs_set_opt(nilfs, STRICT_ORDER); 761 else 762 return 0; 763 break; 764 case Opt_err_panic: 765 nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_PANIC); 766 break; 767 case Opt_err_ro: 768 nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_RO); 769 break; 770 case Opt_err_cont: 771 nilfs_write_opt(nilfs, ERROR_MODE, ERRORS_CONT); 772 break; 773 case Opt_snapshot: 774 if (is_remount) { 775 printk(KERN_ERR 776 "NILFS: \"%s\" option is invalid " 777 "for remount.\n", p); 778 return 0; 779 } 780 break; 781 case Opt_norecovery: 782 nilfs_set_opt(nilfs, NORECOVERY); 783 break; 784 case Opt_discard: 785 nilfs_set_opt(nilfs, DISCARD); 786 break; 787 case Opt_nodiscard: 788 nilfs_clear_opt(nilfs, DISCARD); 789 break; 790 default: 791 printk(KERN_ERR 792 "NILFS: Unrecognized mount option \"%s\"\n", p); 793 return 0; 794 } 795 } 796 return 1; 797 } 798 799 static inline void 800 nilfs_set_default_options(struct super_block *sb, 801 struct nilfs_super_block *sbp) 802 { 803 struct the_nilfs *nilfs = sb->s_fs_info; 804 805 nilfs->ns_mount_opt = 806 NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER; 807 } 808 809 static int nilfs_setup_super(struct super_block *sb, int is_mount) 810 { 811 struct the_nilfs *nilfs = sb->s_fs_info; 812 struct nilfs_super_block **sbp; 813 int max_mnt_count; 814 int mnt_count; 815 816 /* nilfs->ns_sem must be locked by the caller. */ 817 sbp = nilfs_prepare_super(sb, 0); 818 if (!sbp) 819 return -EIO; 820 821 if (!is_mount) 822 goto skip_mount_setup; 823 824 max_mnt_count = le16_to_cpu(sbp[0]->s_max_mnt_count); 825 mnt_count = le16_to_cpu(sbp[0]->s_mnt_count); 826 827 if (nilfs->ns_mount_state & NILFS_ERROR_FS) { 828 printk(KERN_WARNING 829 "NILFS warning: mounting fs with errors\n"); 830 #if 0 831 } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) { 832 printk(KERN_WARNING 833 "NILFS warning: maximal mount count reached\n"); 834 #endif 835 } 836 if (!max_mnt_count) 837 sbp[0]->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT); 838 839 sbp[0]->s_mnt_count = cpu_to_le16(mnt_count + 1); 840 sbp[0]->s_mtime = cpu_to_le64(get_seconds()); 841 842 skip_mount_setup: 843 sbp[0]->s_state = 844 cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & ~NILFS_VALID_FS); 845 /* synchronize sbp[1] with sbp[0] */ 846 if (sbp[1]) 847 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 848 return nilfs_commit_super(sb, NILFS_SB_COMMIT_ALL); 849 } 850 851 struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb, 852 u64 pos, int blocksize, 853 struct buffer_head **pbh) 854 { 855 unsigned long long sb_index = pos; 856 unsigned long offset; 857 858 offset = do_div(sb_index, blocksize); 859 *pbh = sb_bread(sb, sb_index); 860 if (!*pbh) 861 return NULL; 862 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset); 863 } 864 865 int nilfs_store_magic_and_option(struct super_block *sb, 866 struct nilfs_super_block *sbp, 867 char *data) 868 { 869 struct the_nilfs *nilfs = sb->s_fs_info; 870 871 sb->s_magic = le16_to_cpu(sbp->s_magic); 872 873 /* FS independent flags */ 874 #ifdef NILFS_ATIME_DISABLE 875 sb->s_flags |= MS_NOATIME; 876 #endif 877 878 nilfs_set_default_options(sb, sbp); 879 880 nilfs->ns_resuid = le16_to_cpu(sbp->s_def_resuid); 881 nilfs->ns_resgid = le16_to_cpu(sbp->s_def_resgid); 882 nilfs->ns_interval = le32_to_cpu(sbp->s_c_interval); 883 nilfs->ns_watermark = le32_to_cpu(sbp->s_c_block_max); 884 885 return !parse_options(data, sb, 0) ? -EINVAL : 0 ; 886 } 887 888 int nilfs_check_feature_compatibility(struct super_block *sb, 889 struct nilfs_super_block *sbp) 890 { 891 __u64 features; 892 893 features = le64_to_cpu(sbp->s_feature_incompat) & 894 ~NILFS_FEATURE_INCOMPAT_SUPP; 895 if (features) { 896 printk(KERN_ERR "NILFS: couldn't mount because of unsupported " 897 "optional features (%llx)\n", 898 (unsigned long long)features); 899 return -EINVAL; 900 } 901 features = le64_to_cpu(sbp->s_feature_compat_ro) & 902 ~NILFS_FEATURE_COMPAT_RO_SUPP; 903 if (!(sb->s_flags & MS_RDONLY) && features) { 904 printk(KERN_ERR "NILFS: couldn't mount RDWR because of " 905 "unsupported optional features (%llx)\n", 906 (unsigned long long)features); 907 return -EINVAL; 908 } 909 return 0; 910 } 911 912 static int nilfs_get_root_dentry(struct super_block *sb, 913 struct nilfs_root *root, 914 struct dentry **root_dentry) 915 { 916 struct inode *inode; 917 struct dentry *dentry; 918 int ret = 0; 919 920 inode = nilfs_iget(sb, root, NILFS_ROOT_INO); 921 if (IS_ERR(inode)) { 922 printk(KERN_ERR "NILFS: get root inode failed\n"); 923 ret = PTR_ERR(inode); 924 goto out; 925 } 926 if (!S_ISDIR(inode->i_mode) || !inode->i_blocks || !inode->i_size) { 927 iput(inode); 928 printk(KERN_ERR "NILFS: corrupt root inode.\n"); 929 ret = -EINVAL; 930 goto out; 931 } 932 933 if (root->cno == NILFS_CPTREE_CURRENT_CNO) { 934 dentry = d_find_alias(inode); 935 if (!dentry) { 936 dentry = d_make_root(inode); 937 if (!dentry) { 938 ret = -ENOMEM; 939 goto failed_dentry; 940 } 941 } else { 942 iput(inode); 943 } 944 } else { 945 dentry = d_obtain_alias(inode); 946 if (IS_ERR(dentry)) { 947 ret = PTR_ERR(dentry); 948 goto failed_dentry; 949 } 950 } 951 *root_dentry = dentry; 952 out: 953 return ret; 954 955 failed_dentry: 956 printk(KERN_ERR "NILFS: get root dentry failed\n"); 957 goto out; 958 } 959 960 static int nilfs_attach_snapshot(struct super_block *s, __u64 cno, 961 struct dentry **root_dentry) 962 { 963 struct the_nilfs *nilfs = s->s_fs_info; 964 struct nilfs_root *root; 965 int ret; 966 967 mutex_lock(&nilfs->ns_snapshot_mount_mutex); 968 969 down_read(&nilfs->ns_segctor_sem); 970 ret = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, cno); 971 up_read(&nilfs->ns_segctor_sem); 972 if (ret < 0) { 973 ret = (ret == -ENOENT) ? -EINVAL : ret; 974 goto out; 975 } else if (!ret) { 976 printk(KERN_ERR "NILFS: The specified checkpoint is " 977 "not a snapshot (checkpoint number=%llu).\n", 978 (unsigned long long)cno); 979 ret = -EINVAL; 980 goto out; 981 } 982 983 ret = nilfs_attach_checkpoint(s, cno, false, &root); 984 if (ret) { 985 printk(KERN_ERR "NILFS: error loading snapshot " 986 "(checkpoint number=%llu).\n", 987 (unsigned long long)cno); 988 goto out; 989 } 990 ret = nilfs_get_root_dentry(s, root, root_dentry); 991 nilfs_put_root(root); 992 out: 993 mutex_unlock(&nilfs->ns_snapshot_mount_mutex); 994 return ret; 995 } 996 997 /** 998 * nilfs_tree_is_busy() - try to shrink dentries of a checkpoint 999 * @root_dentry: root dentry of the tree to be shrunk 1000 * 1001 * This function returns true if the tree was in-use. 1002 */ 1003 static bool nilfs_tree_is_busy(struct dentry *root_dentry) 1004 { 1005 shrink_dcache_parent(root_dentry); 1006 return d_count(root_dentry) > 1; 1007 } 1008 1009 int nilfs_checkpoint_is_mounted(struct super_block *sb, __u64 cno) 1010 { 1011 struct the_nilfs *nilfs = sb->s_fs_info; 1012 struct nilfs_root *root; 1013 struct inode *inode; 1014 struct dentry *dentry; 1015 int ret; 1016 1017 if (cno < 0 || cno > nilfs->ns_cno) 1018 return false; 1019 1020 if (cno >= nilfs_last_cno(nilfs)) 1021 return true; /* protect recent checkpoints */ 1022 1023 ret = false; 1024 root = nilfs_lookup_root(nilfs, cno); 1025 if (root) { 1026 inode = nilfs_ilookup(sb, root, NILFS_ROOT_INO); 1027 if (inode) { 1028 dentry = d_find_alias(inode); 1029 if (dentry) { 1030 ret = nilfs_tree_is_busy(dentry); 1031 dput(dentry); 1032 } 1033 iput(inode); 1034 } 1035 nilfs_put_root(root); 1036 } 1037 return ret; 1038 } 1039 1040 /** 1041 * nilfs_fill_super() - initialize a super block instance 1042 * @sb: super_block 1043 * @data: mount options 1044 * @silent: silent mode flag 1045 * 1046 * This function is called exclusively by nilfs->ns_mount_mutex. 1047 * So, the recovery process is protected from other simultaneous mounts. 1048 */ 1049 static int 1050 nilfs_fill_super(struct super_block *sb, void *data, int silent) 1051 { 1052 struct the_nilfs *nilfs; 1053 struct nilfs_root *fsroot; 1054 struct backing_dev_info *bdi; 1055 __u64 cno; 1056 int err; 1057 1058 nilfs = alloc_nilfs(sb->s_bdev); 1059 if (!nilfs) 1060 return -ENOMEM; 1061 1062 sb->s_fs_info = nilfs; 1063 1064 err = init_nilfs(nilfs, sb, (char *)data); 1065 if (err) 1066 goto failed_nilfs; 1067 1068 sb->s_op = &nilfs_sops; 1069 sb->s_export_op = &nilfs_export_ops; 1070 sb->s_root = NULL; 1071 sb->s_time_gran = 1; 1072 sb->s_max_links = NILFS_LINK_MAX; 1073 1074 bdi = sb->s_bdev->bd_inode->i_mapping->backing_dev_info; 1075 sb->s_bdi = bdi ? : &default_backing_dev_info; 1076 1077 err = load_nilfs(nilfs, sb); 1078 if (err) 1079 goto failed_nilfs; 1080 1081 cno = nilfs_last_cno(nilfs); 1082 err = nilfs_attach_checkpoint(sb, cno, true, &fsroot); 1083 if (err) { 1084 printk(KERN_ERR "NILFS: error loading last checkpoint " 1085 "(checkpoint number=%llu).\n", (unsigned long long)cno); 1086 goto failed_unload; 1087 } 1088 1089 if (!(sb->s_flags & MS_RDONLY)) { 1090 err = nilfs_attach_log_writer(sb, fsroot); 1091 if (err) 1092 goto failed_checkpoint; 1093 } 1094 1095 err = nilfs_get_root_dentry(sb, fsroot, &sb->s_root); 1096 if (err) 1097 goto failed_segctor; 1098 1099 nilfs_put_root(fsroot); 1100 1101 if (!(sb->s_flags & MS_RDONLY)) { 1102 down_write(&nilfs->ns_sem); 1103 nilfs_setup_super(sb, true); 1104 up_write(&nilfs->ns_sem); 1105 } 1106 1107 return 0; 1108 1109 failed_segctor: 1110 nilfs_detach_log_writer(sb); 1111 1112 failed_checkpoint: 1113 nilfs_put_root(fsroot); 1114 1115 failed_unload: 1116 iput(nilfs->ns_sufile); 1117 iput(nilfs->ns_cpfile); 1118 iput(nilfs->ns_dat); 1119 1120 failed_nilfs: 1121 destroy_nilfs(nilfs); 1122 return err; 1123 } 1124 1125 static int nilfs_remount(struct super_block *sb, int *flags, char *data) 1126 { 1127 struct the_nilfs *nilfs = sb->s_fs_info; 1128 unsigned long old_sb_flags; 1129 unsigned long old_mount_opt; 1130 int err; 1131 1132 old_sb_flags = sb->s_flags; 1133 old_mount_opt = nilfs->ns_mount_opt; 1134 1135 if (!parse_options(data, sb, 1)) { 1136 err = -EINVAL; 1137 goto restore_opts; 1138 } 1139 sb->s_flags = (sb->s_flags & ~MS_POSIXACL); 1140 1141 err = -EINVAL; 1142 1143 if (!nilfs_valid_fs(nilfs)) { 1144 printk(KERN_WARNING "NILFS (device %s): couldn't " 1145 "remount because the filesystem is in an " 1146 "incomplete recovery state.\n", sb->s_id); 1147 goto restore_opts; 1148 } 1149 1150 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 1151 goto out; 1152 if (*flags & MS_RDONLY) { 1153 /* Shutting down log writer */ 1154 nilfs_detach_log_writer(sb); 1155 sb->s_flags |= MS_RDONLY; 1156 1157 /* 1158 * Remounting a valid RW partition RDONLY, so set 1159 * the RDONLY flag and then mark the partition as valid again. 1160 */ 1161 down_write(&nilfs->ns_sem); 1162 nilfs_cleanup_super(sb); 1163 up_write(&nilfs->ns_sem); 1164 } else { 1165 __u64 features; 1166 struct nilfs_root *root; 1167 1168 /* 1169 * Mounting a RDONLY partition read-write, so reread and 1170 * store the current valid flag. (It may have been changed 1171 * by fsck since we originally mounted the partition.) 1172 */ 1173 down_read(&nilfs->ns_sem); 1174 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & 1175 ~NILFS_FEATURE_COMPAT_RO_SUPP; 1176 up_read(&nilfs->ns_sem); 1177 if (features) { 1178 printk(KERN_WARNING "NILFS (device %s): couldn't " 1179 "remount RDWR because of unsupported optional " 1180 "features (%llx)\n", 1181 sb->s_id, (unsigned long long)features); 1182 err = -EROFS; 1183 goto restore_opts; 1184 } 1185 1186 sb->s_flags &= ~MS_RDONLY; 1187 1188 root = NILFS_I(sb->s_root->d_inode)->i_root; 1189 err = nilfs_attach_log_writer(sb, root); 1190 if (err) 1191 goto restore_opts; 1192 1193 down_write(&nilfs->ns_sem); 1194 nilfs_setup_super(sb, true); 1195 up_write(&nilfs->ns_sem); 1196 } 1197 out: 1198 return 0; 1199 1200 restore_opts: 1201 sb->s_flags = old_sb_flags; 1202 nilfs->ns_mount_opt = old_mount_opt; 1203 return err; 1204 } 1205 1206 struct nilfs_super_data { 1207 struct block_device *bdev; 1208 __u64 cno; 1209 int flags; 1210 }; 1211 1212 /** 1213 * nilfs_identify - pre-read mount options needed to identify mount instance 1214 * @data: mount options 1215 * @sd: nilfs_super_data 1216 */ 1217 static int nilfs_identify(char *data, struct nilfs_super_data *sd) 1218 { 1219 char *p, *options = data; 1220 substring_t args[MAX_OPT_ARGS]; 1221 int token; 1222 int ret = 0; 1223 1224 do { 1225 p = strsep(&options, ","); 1226 if (p != NULL && *p) { 1227 token = match_token(p, tokens, args); 1228 if (token == Opt_snapshot) { 1229 if (!(sd->flags & MS_RDONLY)) { 1230 ret++; 1231 } else { 1232 sd->cno = simple_strtoull(args[0].from, 1233 NULL, 0); 1234 /* 1235 * No need to see the end pointer; 1236 * match_token() has done syntax 1237 * checking. 1238 */ 1239 if (sd->cno == 0) 1240 ret++; 1241 } 1242 } 1243 if (ret) 1244 printk(KERN_ERR 1245 "NILFS: invalid mount option: %s\n", p); 1246 } 1247 if (!options) 1248 break; 1249 BUG_ON(options == data); 1250 *(options - 1) = ','; 1251 } while (!ret); 1252 return ret; 1253 } 1254 1255 static int nilfs_set_bdev_super(struct super_block *s, void *data) 1256 { 1257 s->s_bdev = data; 1258 s->s_dev = s->s_bdev->bd_dev; 1259 return 0; 1260 } 1261 1262 static int nilfs_test_bdev_super(struct super_block *s, void *data) 1263 { 1264 return (void *)s->s_bdev == data; 1265 } 1266 1267 static struct dentry * 1268 nilfs_mount(struct file_system_type *fs_type, int flags, 1269 const char *dev_name, void *data) 1270 { 1271 struct nilfs_super_data sd; 1272 struct super_block *s; 1273 fmode_t mode = FMODE_READ | FMODE_EXCL; 1274 struct dentry *root_dentry; 1275 int err, s_new = false; 1276 1277 if (!(flags & MS_RDONLY)) 1278 mode |= FMODE_WRITE; 1279 1280 sd.bdev = blkdev_get_by_path(dev_name, mode, fs_type); 1281 if (IS_ERR(sd.bdev)) 1282 return ERR_CAST(sd.bdev); 1283 1284 sd.cno = 0; 1285 sd.flags = flags; 1286 if (nilfs_identify((char *)data, &sd)) { 1287 err = -EINVAL; 1288 goto failed; 1289 } 1290 1291 /* 1292 * once the super is inserted into the list by sget, s_umount 1293 * will protect the lockfs code from trying to start a snapshot 1294 * while we are mounting 1295 */ 1296 mutex_lock(&sd.bdev->bd_fsfreeze_mutex); 1297 if (sd.bdev->bd_fsfreeze_count > 0) { 1298 mutex_unlock(&sd.bdev->bd_fsfreeze_mutex); 1299 err = -EBUSY; 1300 goto failed; 1301 } 1302 s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, flags, 1303 sd.bdev); 1304 mutex_unlock(&sd.bdev->bd_fsfreeze_mutex); 1305 if (IS_ERR(s)) { 1306 err = PTR_ERR(s); 1307 goto failed; 1308 } 1309 1310 if (!s->s_root) { 1311 char b[BDEVNAME_SIZE]; 1312 1313 s_new = true; 1314 1315 /* New superblock instance created */ 1316 s->s_mode = mode; 1317 strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id)); 1318 sb_set_blocksize(s, block_size(sd.bdev)); 1319 1320 err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0); 1321 if (err) 1322 goto failed_super; 1323 1324 s->s_flags |= MS_ACTIVE; 1325 } else if (!sd.cno) { 1326 if (nilfs_tree_is_busy(s->s_root)) { 1327 if ((flags ^ s->s_flags) & MS_RDONLY) { 1328 printk(KERN_ERR "NILFS: the device already " 1329 "has a %s mount.\n", 1330 (s->s_flags & MS_RDONLY) ? 1331 "read-only" : "read/write"); 1332 err = -EBUSY; 1333 goto failed_super; 1334 } 1335 } else { 1336 /* 1337 * Try remount to setup mount states if the current 1338 * tree is not mounted and only snapshots use this sb. 1339 */ 1340 err = nilfs_remount(s, &flags, data); 1341 if (err) 1342 goto failed_super; 1343 } 1344 } 1345 1346 if (sd.cno) { 1347 err = nilfs_attach_snapshot(s, sd.cno, &root_dentry); 1348 if (err) 1349 goto failed_super; 1350 } else { 1351 root_dentry = dget(s->s_root); 1352 } 1353 1354 if (!s_new) 1355 blkdev_put(sd.bdev, mode); 1356 1357 return root_dentry; 1358 1359 failed_super: 1360 deactivate_locked_super(s); 1361 1362 failed: 1363 if (!s_new) 1364 blkdev_put(sd.bdev, mode); 1365 return ERR_PTR(err); 1366 } 1367 1368 struct file_system_type nilfs_fs_type = { 1369 .owner = THIS_MODULE, 1370 .name = "nilfs2", 1371 .mount = nilfs_mount, 1372 .kill_sb = kill_block_super, 1373 .fs_flags = FS_REQUIRES_DEV, 1374 }; 1375 MODULE_ALIAS_FS("nilfs2"); 1376 1377 static void nilfs_inode_init_once(void *obj) 1378 { 1379 struct nilfs_inode_info *ii = obj; 1380 1381 INIT_LIST_HEAD(&ii->i_dirty); 1382 #ifdef CONFIG_NILFS_XATTR 1383 init_rwsem(&ii->xattr_sem); 1384 #endif 1385 address_space_init_once(&ii->i_btnode_cache); 1386 ii->i_bmap = &ii->i_bmap_data; 1387 inode_init_once(&ii->vfs_inode); 1388 } 1389 1390 static void nilfs_segbuf_init_once(void *obj) 1391 { 1392 memset(obj, 0, sizeof(struct nilfs_segment_buffer)); 1393 } 1394 1395 static void nilfs_destroy_cachep(void) 1396 { 1397 /* 1398 * Make sure all delayed rcu free inodes are flushed before we 1399 * destroy cache. 1400 */ 1401 rcu_barrier(); 1402 1403 if (nilfs_inode_cachep) 1404 kmem_cache_destroy(nilfs_inode_cachep); 1405 if (nilfs_transaction_cachep) 1406 kmem_cache_destroy(nilfs_transaction_cachep); 1407 if (nilfs_segbuf_cachep) 1408 kmem_cache_destroy(nilfs_segbuf_cachep); 1409 if (nilfs_btree_path_cache) 1410 kmem_cache_destroy(nilfs_btree_path_cache); 1411 } 1412 1413 static int __init nilfs_init_cachep(void) 1414 { 1415 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", 1416 sizeof(struct nilfs_inode_info), 0, 1417 SLAB_RECLAIM_ACCOUNT, nilfs_inode_init_once); 1418 if (!nilfs_inode_cachep) 1419 goto fail; 1420 1421 nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache", 1422 sizeof(struct nilfs_transaction_info), 0, 1423 SLAB_RECLAIM_ACCOUNT, NULL); 1424 if (!nilfs_transaction_cachep) 1425 goto fail; 1426 1427 nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache", 1428 sizeof(struct nilfs_segment_buffer), 0, 1429 SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once); 1430 if (!nilfs_segbuf_cachep) 1431 goto fail; 1432 1433 nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache", 1434 sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX, 1435 0, 0, NULL); 1436 if (!nilfs_btree_path_cache) 1437 goto fail; 1438 1439 return 0; 1440 1441 fail: 1442 nilfs_destroy_cachep(); 1443 return -ENOMEM; 1444 } 1445 1446 static int __init init_nilfs_fs(void) 1447 { 1448 int err; 1449 1450 err = nilfs_init_cachep(); 1451 if (err) 1452 goto fail; 1453 1454 err = register_filesystem(&nilfs_fs_type); 1455 if (err) 1456 goto free_cachep; 1457 1458 printk(KERN_INFO "NILFS version 2 loaded\n"); 1459 return 0; 1460 1461 free_cachep: 1462 nilfs_destroy_cachep(); 1463 fail: 1464 return err; 1465 } 1466 1467 static void __exit exit_nilfs_fs(void) 1468 { 1469 nilfs_destroy_cachep(); 1470 unregister_filesystem(&nilfs_fs_type); 1471 } 1472 1473 module_init(init_nilfs_fs) 1474 module_exit(exit_nilfs_fs) 1475