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