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