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