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/random.h> 47 #include <linux/crc32.h> 48 #include <linux/smp_lock.h> 49 #include <linux/vfs.h> 50 #include <linux/writeback.h> 51 #include <linux/kobject.h> 52 #include <linux/exportfs.h> 53 #include <linux/seq_file.h> 54 #include <linux/mount.h> 55 #include "nilfs.h" 56 #include "mdt.h" 57 #include "alloc.h" 58 #include "page.h" 59 #include "cpfile.h" 60 #include "ifile.h" 61 #include "dat.h" 62 #include "segment.h" 63 #include "segbuf.h" 64 65 MODULE_AUTHOR("NTT Corp."); 66 MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem " 67 "(NILFS)"); 68 MODULE_LICENSE("GPL"); 69 70 static int nilfs_remount(struct super_block *sb, int *flags, char *data); 71 72 /** 73 * nilfs_error() - report failure condition on a filesystem 74 * 75 * nilfs_error() sets an ERROR_FS flag on the superblock as well as 76 * reporting an error message. It should be called when NILFS detects 77 * incoherences or defects of meta data on disk. As for sustainable 78 * errors such as a single-shot I/O error, nilfs_warning() or the printk() 79 * function should be used instead. 80 * 81 * The segment constructor must not call this function because it can 82 * kill itself. 83 */ 84 void nilfs_error(struct super_block *sb, const char *function, 85 const char *fmt, ...) 86 { 87 struct nilfs_sb_info *sbi = NILFS_SB(sb); 88 va_list args; 89 90 va_start(args, fmt); 91 printk(KERN_CRIT "NILFS error (device %s): %s: ", sb->s_id, function); 92 vprintk(fmt, args); 93 printk("\n"); 94 va_end(args); 95 96 if (!(sb->s_flags & MS_RDONLY)) { 97 struct the_nilfs *nilfs = sbi->s_nilfs; 98 99 down_write(&nilfs->ns_sem); 100 if (!(nilfs->ns_mount_state & NILFS_ERROR_FS)) { 101 nilfs->ns_mount_state |= NILFS_ERROR_FS; 102 nilfs->ns_sbp[0]->s_state |= 103 cpu_to_le16(NILFS_ERROR_FS); 104 nilfs_commit_super(sbi, 1); 105 } 106 up_write(&nilfs->ns_sem); 107 108 if (nilfs_test_opt(sbi, ERRORS_RO)) { 109 printk(KERN_CRIT "Remounting filesystem read-only\n"); 110 sb->s_flags |= MS_RDONLY; 111 } 112 } 113 114 if (nilfs_test_opt(sbi, ERRORS_PANIC)) 115 panic("NILFS (device %s): panic forced after error\n", 116 sb->s_id); 117 } 118 119 void nilfs_warning(struct super_block *sb, const char *function, 120 const char *fmt, ...) 121 { 122 va_list args; 123 124 va_start(args, fmt); 125 printk(KERN_WARNING "NILFS warning (device %s): %s: ", 126 sb->s_id, function); 127 vprintk(fmt, args); 128 printk("\n"); 129 va_end(args); 130 } 131 132 static struct kmem_cache *nilfs_inode_cachep; 133 134 struct inode *nilfs_alloc_inode_common(struct the_nilfs *nilfs) 135 { 136 struct nilfs_inode_info *ii; 137 138 ii = kmem_cache_alloc(nilfs_inode_cachep, GFP_NOFS); 139 if (!ii) 140 return NULL; 141 ii->i_bh = NULL; 142 ii->i_state = 0; 143 ii->vfs_inode.i_version = 1; 144 nilfs_btnode_cache_init(&ii->i_btnode_cache, nilfs->ns_bdi); 145 return &ii->vfs_inode; 146 } 147 148 struct inode *nilfs_alloc_inode(struct super_block *sb) 149 { 150 return nilfs_alloc_inode_common(NILFS_SB(sb)->s_nilfs); 151 } 152 153 void nilfs_destroy_inode(struct inode *inode) 154 { 155 kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode)); 156 } 157 158 static void init_once(void *obj) 159 { 160 struct nilfs_inode_info *ii = obj; 161 162 INIT_LIST_HEAD(&ii->i_dirty); 163 #ifdef CONFIG_NILFS_XATTR 164 init_rwsem(&ii->xattr_sem); 165 #endif 166 nilfs_btnode_cache_init_once(&ii->i_btnode_cache); 167 ii->i_bmap = (struct nilfs_bmap *)&ii->i_bmap_union; 168 inode_init_once(&ii->vfs_inode); 169 } 170 171 static int nilfs_init_inode_cache(void) 172 { 173 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", 174 sizeof(struct nilfs_inode_info), 175 0, SLAB_RECLAIM_ACCOUNT, 176 init_once); 177 178 return (nilfs_inode_cachep == NULL) ? -ENOMEM : 0; 179 } 180 181 static inline void nilfs_destroy_inode_cache(void) 182 { 183 kmem_cache_destroy(nilfs_inode_cachep); 184 } 185 186 static void nilfs_clear_inode(struct inode *inode) 187 { 188 struct nilfs_inode_info *ii = NILFS_I(inode); 189 190 /* 191 * Free resources allocated in nilfs_read_inode(), here. 192 */ 193 BUG_ON(!list_empty(&ii->i_dirty)); 194 brelse(ii->i_bh); 195 ii->i_bh = NULL; 196 197 if (test_bit(NILFS_I_BMAP, &ii->i_state)) 198 nilfs_bmap_clear(ii->i_bmap); 199 200 nilfs_btnode_cache_clear(&ii->i_btnode_cache); 201 } 202 203 static int nilfs_sync_super(struct nilfs_sb_info *sbi, int dupsb) 204 { 205 struct the_nilfs *nilfs = sbi->s_nilfs; 206 int err; 207 int barrier_done = 0; 208 209 if (nilfs_test_opt(sbi, BARRIER)) { 210 set_buffer_ordered(nilfs->ns_sbh[0]); 211 barrier_done = 1; 212 } 213 retry: 214 set_buffer_dirty(nilfs->ns_sbh[0]); 215 err = sync_dirty_buffer(nilfs->ns_sbh[0]); 216 if (err == -EOPNOTSUPP && barrier_done) { 217 nilfs_warning(sbi->s_super, __func__, 218 "barrier-based sync failed. " 219 "disabling barriers\n"); 220 nilfs_clear_opt(sbi, BARRIER); 221 barrier_done = 0; 222 clear_buffer_ordered(nilfs->ns_sbh[0]); 223 goto retry; 224 } 225 if (unlikely(err)) { 226 printk(KERN_ERR 227 "NILFS: unable to write superblock (err=%d)\n", err); 228 if (err == -EIO && nilfs->ns_sbh[1]) { 229 nilfs_fall_back_super_block(nilfs); 230 goto retry; 231 } 232 } else { 233 struct nilfs_super_block *sbp = nilfs->ns_sbp[0]; 234 235 /* 236 * The latest segment becomes trailable from the position 237 * written in superblock. 238 */ 239 clear_nilfs_discontinued(nilfs); 240 241 /* update GC protection for recent segments */ 242 if (nilfs->ns_sbh[1]) { 243 sbp = NULL; 244 if (dupsb) { 245 set_buffer_dirty(nilfs->ns_sbh[1]); 246 if (!sync_dirty_buffer(nilfs->ns_sbh[1])) 247 sbp = nilfs->ns_sbp[1]; 248 } 249 } 250 if (sbp) { 251 spin_lock(&nilfs->ns_last_segment_lock); 252 nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq); 253 spin_unlock(&nilfs->ns_last_segment_lock); 254 } 255 } 256 257 return err; 258 } 259 260 int nilfs_commit_super(struct nilfs_sb_info *sbi, int dupsb) 261 { 262 struct the_nilfs *nilfs = sbi->s_nilfs; 263 struct nilfs_super_block **sbp = nilfs->ns_sbp; 264 sector_t nfreeblocks; 265 time_t t; 266 int err; 267 268 /* nilfs->sem must be locked by the caller. */ 269 if (sbp[0]->s_magic != NILFS_SUPER_MAGIC) { 270 if (sbp[1] && sbp[1]->s_magic == NILFS_SUPER_MAGIC) 271 nilfs_swap_super_block(nilfs); 272 else { 273 printk(KERN_CRIT "NILFS: superblock broke on dev %s\n", 274 sbi->s_super->s_id); 275 return -EIO; 276 } 277 } 278 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 279 if (unlikely(err)) { 280 printk(KERN_ERR "NILFS: failed to count free blocks\n"); 281 return err; 282 } 283 spin_lock(&nilfs->ns_last_segment_lock); 284 sbp[0]->s_last_seq = cpu_to_le64(nilfs->ns_last_seq); 285 sbp[0]->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg); 286 sbp[0]->s_last_cno = cpu_to_le64(nilfs->ns_last_cno); 287 spin_unlock(&nilfs->ns_last_segment_lock); 288 289 t = get_seconds(); 290 nilfs->ns_sbwtime[0] = t; 291 sbp[0]->s_free_blocks_count = cpu_to_le64(nfreeblocks); 292 sbp[0]->s_wtime = cpu_to_le64(t); 293 sbp[0]->s_sum = 0; 294 sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 295 (unsigned char *)sbp[0], 296 nilfs->ns_sbsize)); 297 if (dupsb && sbp[1]) { 298 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 299 nilfs->ns_sbwtime[1] = t; 300 } 301 clear_nilfs_sb_dirty(nilfs); 302 return nilfs_sync_super(sbi, dupsb); 303 } 304 305 static void nilfs_put_super(struct super_block *sb) 306 { 307 struct nilfs_sb_info *sbi = NILFS_SB(sb); 308 struct the_nilfs *nilfs = sbi->s_nilfs; 309 310 lock_kernel(); 311 312 nilfs_detach_segment_constructor(sbi); 313 314 if (!(sb->s_flags & MS_RDONLY)) { 315 down_write(&nilfs->ns_sem); 316 nilfs->ns_sbp[0]->s_state = cpu_to_le16(nilfs->ns_mount_state); 317 nilfs_commit_super(sbi, 1); 318 up_write(&nilfs->ns_sem); 319 } 320 down_write(&nilfs->ns_super_sem); 321 if (nilfs->ns_current == sbi) 322 nilfs->ns_current = NULL; 323 up_write(&nilfs->ns_super_sem); 324 325 nilfs_detach_checkpoint(sbi); 326 put_nilfs(sbi->s_nilfs); 327 sbi->s_super = NULL; 328 sb->s_fs_info = NULL; 329 nilfs_put_sbinfo(sbi); 330 331 unlock_kernel(); 332 } 333 334 static int nilfs_sync_fs(struct super_block *sb, int wait) 335 { 336 struct nilfs_sb_info *sbi = NILFS_SB(sb); 337 struct the_nilfs *nilfs = sbi->s_nilfs; 338 int err = 0; 339 340 /* This function is called when super block should be written back */ 341 if (wait) 342 err = nilfs_construct_segment(sb); 343 344 down_write(&nilfs->ns_sem); 345 if (nilfs_sb_dirty(nilfs)) 346 nilfs_commit_super(sbi, 1); 347 up_write(&nilfs->ns_sem); 348 349 return err; 350 } 351 352 int nilfs_attach_checkpoint(struct nilfs_sb_info *sbi, __u64 cno) 353 { 354 struct the_nilfs *nilfs = sbi->s_nilfs; 355 struct nilfs_checkpoint *raw_cp; 356 struct buffer_head *bh_cp; 357 int err; 358 359 down_write(&nilfs->ns_super_sem); 360 list_add(&sbi->s_list, &nilfs->ns_supers); 361 up_write(&nilfs->ns_super_sem); 362 363 sbi->s_ifile = nilfs_ifile_new(sbi, nilfs->ns_inode_size); 364 if (!sbi->s_ifile) 365 return -ENOMEM; 366 367 down_read(&nilfs->ns_segctor_sem); 368 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp, 369 &bh_cp); 370 up_read(&nilfs->ns_segctor_sem); 371 if (unlikely(err)) { 372 if (err == -ENOENT || err == -EINVAL) { 373 printk(KERN_ERR 374 "NILFS: Invalid checkpoint " 375 "(checkpoint number=%llu)\n", 376 (unsigned long long)cno); 377 err = -EINVAL; 378 } 379 goto failed; 380 } 381 err = nilfs_read_inode_common(sbi->s_ifile, &raw_cp->cp_ifile_inode); 382 if (unlikely(err)) 383 goto failed_bh; 384 atomic_set(&sbi->s_inodes_count, le64_to_cpu(raw_cp->cp_inodes_count)); 385 atomic_set(&sbi->s_blocks_count, le64_to_cpu(raw_cp->cp_blocks_count)); 386 387 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 388 return 0; 389 390 failed_bh: 391 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 392 failed: 393 nilfs_mdt_destroy(sbi->s_ifile); 394 sbi->s_ifile = NULL; 395 396 down_write(&nilfs->ns_super_sem); 397 list_del_init(&sbi->s_list); 398 up_write(&nilfs->ns_super_sem); 399 400 return err; 401 } 402 403 void nilfs_detach_checkpoint(struct nilfs_sb_info *sbi) 404 { 405 struct the_nilfs *nilfs = sbi->s_nilfs; 406 407 nilfs_mdt_destroy(sbi->s_ifile); 408 sbi->s_ifile = NULL; 409 down_write(&nilfs->ns_super_sem); 410 list_del_init(&sbi->s_list); 411 up_write(&nilfs->ns_super_sem); 412 } 413 414 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 415 { 416 struct super_block *sb = dentry->d_sb; 417 struct nilfs_sb_info *sbi = NILFS_SB(sb); 418 struct the_nilfs *nilfs = sbi->s_nilfs; 419 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 420 unsigned long long blocks; 421 unsigned long overhead; 422 unsigned long nrsvblocks; 423 sector_t nfreeblocks; 424 int err; 425 426 /* 427 * Compute all of the segment blocks 428 * 429 * The blocks before first segment and after last segment 430 * are excluded. 431 */ 432 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments 433 - nilfs->ns_first_data_block; 434 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment; 435 436 /* 437 * Compute the overhead 438 * 439 * When distributing meta data blocks outside segment structure, 440 * We must count them as the overhead. 441 */ 442 overhead = 0; 443 444 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 445 if (unlikely(err)) 446 return err; 447 448 buf->f_type = NILFS_SUPER_MAGIC; 449 buf->f_bsize = sb->s_blocksize; 450 buf->f_blocks = blocks - overhead; 451 buf->f_bfree = nfreeblocks; 452 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? 453 (buf->f_bfree - nrsvblocks) : 0; 454 buf->f_files = atomic_read(&sbi->s_inodes_count); 455 buf->f_ffree = 0; /* nilfs_count_free_inodes(sb); */ 456 buf->f_namelen = NILFS_NAME_LEN; 457 buf->f_fsid.val[0] = (u32)id; 458 buf->f_fsid.val[1] = (u32)(id >> 32); 459 460 return 0; 461 } 462 463 static int nilfs_show_options(struct seq_file *seq, struct vfsmount *vfs) 464 { 465 struct super_block *sb = vfs->mnt_sb; 466 struct nilfs_sb_info *sbi = NILFS_SB(sb); 467 468 if (!nilfs_test_opt(sbi, BARRIER)) 469 seq_printf(seq, ",nobarrier"); 470 if (nilfs_test_opt(sbi, SNAPSHOT)) 471 seq_printf(seq, ",cp=%llu", 472 (unsigned long long int)sbi->s_snapshot_cno); 473 if (nilfs_test_opt(sbi, ERRORS_RO)) 474 seq_printf(seq, ",errors=remount-ro"); 475 if (nilfs_test_opt(sbi, ERRORS_PANIC)) 476 seq_printf(seq, ",errors=panic"); 477 if (nilfs_test_opt(sbi, STRICT_ORDER)) 478 seq_printf(seq, ",order=strict"); 479 if (nilfs_test_opt(sbi, NORECOVERY)) 480 seq_printf(seq, ",norecovery"); 481 if (nilfs_test_opt(sbi, DISCARD)) 482 seq_printf(seq, ",discard"); 483 484 return 0; 485 } 486 487 static const struct super_operations nilfs_sops = { 488 .alloc_inode = nilfs_alloc_inode, 489 .destroy_inode = nilfs_destroy_inode, 490 .dirty_inode = nilfs_dirty_inode, 491 /* .write_inode = nilfs_write_inode, */ 492 /* .put_inode = nilfs_put_inode, */ 493 /* .drop_inode = nilfs_drop_inode, */ 494 .delete_inode = nilfs_delete_inode, 495 .put_super = nilfs_put_super, 496 /* .write_super = nilfs_write_super, */ 497 .sync_fs = nilfs_sync_fs, 498 /* .write_super_lockfs */ 499 /* .unlockfs */ 500 .statfs = nilfs_statfs, 501 .remount_fs = nilfs_remount, 502 .clear_inode = nilfs_clear_inode, 503 /* .umount_begin */ 504 .show_options = nilfs_show_options 505 }; 506 507 static struct inode * 508 nilfs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation) 509 { 510 struct inode *inode; 511 512 if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO && 513 ino != NILFS_SKETCH_INO) 514 return ERR_PTR(-ESTALE); 515 516 inode = nilfs_iget(sb, ino); 517 if (IS_ERR(inode)) 518 return ERR_CAST(inode); 519 if (generation && inode->i_generation != generation) { 520 iput(inode); 521 return ERR_PTR(-ESTALE); 522 } 523 524 return inode; 525 } 526 527 static struct dentry * 528 nilfs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, 529 int fh_type) 530 { 531 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 532 nilfs_nfs_get_inode); 533 } 534 535 static struct dentry * 536 nilfs_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, 537 int fh_type) 538 { 539 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 540 nilfs_nfs_get_inode); 541 } 542 543 static const struct export_operations nilfs_export_ops = { 544 .fh_to_dentry = nilfs_fh_to_dentry, 545 .fh_to_parent = nilfs_fh_to_parent, 546 .get_parent = nilfs_get_parent, 547 }; 548 549 enum { 550 Opt_err_cont, Opt_err_panic, Opt_err_ro, 551 Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery, 552 Opt_discard, Opt_err, 553 }; 554 555 static match_table_t tokens = { 556 {Opt_err_cont, "errors=continue"}, 557 {Opt_err_panic, "errors=panic"}, 558 {Opt_err_ro, "errors=remount-ro"}, 559 {Opt_nobarrier, "nobarrier"}, 560 {Opt_snapshot, "cp=%u"}, 561 {Opt_order, "order=%s"}, 562 {Opt_norecovery, "norecovery"}, 563 {Opt_discard, "discard"}, 564 {Opt_err, NULL} 565 }; 566 567 static int parse_options(char *options, struct super_block *sb) 568 { 569 struct nilfs_sb_info *sbi = NILFS_SB(sb); 570 char *p; 571 substring_t args[MAX_OPT_ARGS]; 572 int option; 573 574 if (!options) 575 return 1; 576 577 while ((p = strsep(&options, ",")) != NULL) { 578 int token; 579 if (!*p) 580 continue; 581 582 token = match_token(p, tokens, args); 583 switch (token) { 584 case Opt_nobarrier: 585 nilfs_clear_opt(sbi, BARRIER); 586 break; 587 case Opt_order: 588 if (strcmp(args[0].from, "relaxed") == 0) 589 /* Ordered data semantics */ 590 nilfs_clear_opt(sbi, STRICT_ORDER); 591 else if (strcmp(args[0].from, "strict") == 0) 592 /* Strict in-order semantics */ 593 nilfs_set_opt(sbi, STRICT_ORDER); 594 else 595 return 0; 596 break; 597 case Opt_err_panic: 598 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_PANIC); 599 break; 600 case Opt_err_ro: 601 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_RO); 602 break; 603 case Opt_err_cont: 604 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_CONT); 605 break; 606 case Opt_snapshot: 607 if (match_int(&args[0], &option) || option <= 0) 608 return 0; 609 if (!(sb->s_flags & MS_RDONLY)) 610 return 0; 611 sbi->s_snapshot_cno = option; 612 nilfs_set_opt(sbi, SNAPSHOT); 613 break; 614 case Opt_norecovery: 615 nilfs_set_opt(sbi, NORECOVERY); 616 break; 617 case Opt_discard: 618 nilfs_set_opt(sbi, DISCARD); 619 break; 620 default: 621 printk(KERN_ERR 622 "NILFS: Unrecognized mount option \"%s\"\n", p); 623 return 0; 624 } 625 } 626 return 1; 627 } 628 629 static inline void 630 nilfs_set_default_options(struct nilfs_sb_info *sbi, 631 struct nilfs_super_block *sbp) 632 { 633 sbi->s_mount_opt = 634 NILFS_MOUNT_ERRORS_CONT | NILFS_MOUNT_BARRIER; 635 } 636 637 static int nilfs_setup_super(struct nilfs_sb_info *sbi) 638 { 639 struct the_nilfs *nilfs = sbi->s_nilfs; 640 struct nilfs_super_block *sbp = nilfs->ns_sbp[0]; 641 int max_mnt_count = le16_to_cpu(sbp->s_max_mnt_count); 642 int mnt_count = le16_to_cpu(sbp->s_mnt_count); 643 644 /* nilfs->sem must be locked by the caller. */ 645 if (nilfs->ns_mount_state & NILFS_ERROR_FS) { 646 printk(KERN_WARNING 647 "NILFS warning: mounting fs with errors\n"); 648 #if 0 649 } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) { 650 printk(KERN_WARNING 651 "NILFS warning: maximal mount count reached\n"); 652 #endif 653 } 654 if (!max_mnt_count) 655 sbp->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT); 656 657 sbp->s_mnt_count = cpu_to_le16(mnt_count + 1); 658 sbp->s_state = cpu_to_le16(le16_to_cpu(sbp->s_state) & ~NILFS_VALID_FS); 659 sbp->s_mtime = cpu_to_le64(get_seconds()); 660 return nilfs_commit_super(sbi, 1); 661 } 662 663 struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb, 664 u64 pos, int blocksize, 665 struct buffer_head **pbh) 666 { 667 unsigned long long sb_index = pos; 668 unsigned long offset; 669 670 offset = do_div(sb_index, blocksize); 671 *pbh = sb_bread(sb, sb_index); 672 if (!*pbh) 673 return NULL; 674 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset); 675 } 676 677 int nilfs_store_magic_and_option(struct super_block *sb, 678 struct nilfs_super_block *sbp, 679 char *data) 680 { 681 struct nilfs_sb_info *sbi = NILFS_SB(sb); 682 683 sb->s_magic = le16_to_cpu(sbp->s_magic); 684 685 /* FS independent flags */ 686 #ifdef NILFS_ATIME_DISABLE 687 sb->s_flags |= MS_NOATIME; 688 #endif 689 690 nilfs_set_default_options(sbi, sbp); 691 692 sbi->s_resuid = le16_to_cpu(sbp->s_def_resuid); 693 sbi->s_resgid = le16_to_cpu(sbp->s_def_resgid); 694 sbi->s_interval = le32_to_cpu(sbp->s_c_interval); 695 sbi->s_watermark = le32_to_cpu(sbp->s_c_block_max); 696 697 return !parse_options(data, sb) ? -EINVAL : 0 ; 698 } 699 700 /** 701 * nilfs_fill_super() - initialize a super block instance 702 * @sb: super_block 703 * @data: mount options 704 * @silent: silent mode flag 705 * @nilfs: the_nilfs struct 706 * 707 * This function is called exclusively by nilfs->ns_mount_mutex. 708 * So, the recovery process is protected from other simultaneous mounts. 709 */ 710 static int 711 nilfs_fill_super(struct super_block *sb, void *data, int silent, 712 struct the_nilfs *nilfs) 713 { 714 struct nilfs_sb_info *sbi; 715 struct inode *root; 716 __u64 cno; 717 int err; 718 719 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); 720 if (!sbi) 721 return -ENOMEM; 722 723 sb->s_fs_info = sbi; 724 725 get_nilfs(nilfs); 726 sbi->s_nilfs = nilfs; 727 sbi->s_super = sb; 728 atomic_set(&sbi->s_count, 1); 729 730 err = init_nilfs(nilfs, sbi, (char *)data); 731 if (err) 732 goto failed_sbi; 733 734 spin_lock_init(&sbi->s_inode_lock); 735 INIT_LIST_HEAD(&sbi->s_dirty_files); 736 INIT_LIST_HEAD(&sbi->s_list); 737 738 /* 739 * Following initialization is overlapped because 740 * nilfs_sb_info structure has been cleared at the beginning. 741 * But we reserve them to keep our interest and make ready 742 * for the future change. 743 */ 744 get_random_bytes(&sbi->s_next_generation, 745 sizeof(sbi->s_next_generation)); 746 spin_lock_init(&sbi->s_next_gen_lock); 747 748 sb->s_op = &nilfs_sops; 749 sb->s_export_op = &nilfs_export_ops; 750 sb->s_root = NULL; 751 sb->s_time_gran = 1; 752 sb->s_bdi = nilfs->ns_bdi; 753 754 err = load_nilfs(nilfs, sbi); 755 if (err) 756 goto failed_sbi; 757 758 cno = nilfs_last_cno(nilfs); 759 760 if (sb->s_flags & MS_RDONLY) { 761 if (nilfs_test_opt(sbi, SNAPSHOT)) { 762 down_read(&nilfs->ns_segctor_sem); 763 err = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, 764 sbi->s_snapshot_cno); 765 up_read(&nilfs->ns_segctor_sem); 766 if (err < 0) { 767 if (err == -ENOENT) 768 err = -EINVAL; 769 goto failed_sbi; 770 } 771 if (!err) { 772 printk(KERN_ERR 773 "NILFS: The specified checkpoint is " 774 "not a snapshot " 775 "(checkpoint number=%llu).\n", 776 (unsigned long long)sbi->s_snapshot_cno); 777 err = -EINVAL; 778 goto failed_sbi; 779 } 780 cno = sbi->s_snapshot_cno; 781 } else 782 /* Read-only mount */ 783 sbi->s_snapshot_cno = cno; 784 } 785 786 err = nilfs_attach_checkpoint(sbi, cno); 787 if (err) { 788 printk(KERN_ERR "NILFS: error loading a checkpoint" 789 " (checkpoint number=%llu).\n", (unsigned long long)cno); 790 goto failed_sbi; 791 } 792 793 if (!(sb->s_flags & MS_RDONLY)) { 794 err = nilfs_attach_segment_constructor(sbi); 795 if (err) 796 goto failed_checkpoint; 797 } 798 799 root = nilfs_iget(sb, NILFS_ROOT_INO); 800 if (IS_ERR(root)) { 801 printk(KERN_ERR "NILFS: get root inode failed\n"); 802 err = PTR_ERR(root); 803 goto failed_segctor; 804 } 805 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { 806 iput(root); 807 printk(KERN_ERR "NILFS: corrupt root inode.\n"); 808 err = -EINVAL; 809 goto failed_segctor; 810 } 811 sb->s_root = d_alloc_root(root); 812 if (!sb->s_root) { 813 iput(root); 814 printk(KERN_ERR "NILFS: get root dentry failed\n"); 815 err = -ENOMEM; 816 goto failed_segctor; 817 } 818 819 if (!(sb->s_flags & MS_RDONLY)) { 820 down_write(&nilfs->ns_sem); 821 nilfs_setup_super(sbi); 822 up_write(&nilfs->ns_sem); 823 } 824 825 down_write(&nilfs->ns_super_sem); 826 if (!nilfs_test_opt(sbi, SNAPSHOT)) 827 nilfs->ns_current = sbi; 828 up_write(&nilfs->ns_super_sem); 829 830 return 0; 831 832 failed_segctor: 833 nilfs_detach_segment_constructor(sbi); 834 835 failed_checkpoint: 836 nilfs_detach_checkpoint(sbi); 837 838 failed_sbi: 839 put_nilfs(nilfs); 840 sb->s_fs_info = NULL; 841 nilfs_put_sbinfo(sbi); 842 return err; 843 } 844 845 static int nilfs_remount(struct super_block *sb, int *flags, char *data) 846 { 847 struct nilfs_sb_info *sbi = NILFS_SB(sb); 848 struct nilfs_super_block *sbp; 849 struct the_nilfs *nilfs = sbi->s_nilfs; 850 unsigned long old_sb_flags; 851 struct nilfs_mount_options old_opts; 852 int err; 853 854 lock_kernel(); 855 856 down_write(&nilfs->ns_super_sem); 857 old_sb_flags = sb->s_flags; 858 old_opts.mount_opt = sbi->s_mount_opt; 859 old_opts.snapshot_cno = sbi->s_snapshot_cno; 860 861 if (!parse_options(data, sb)) { 862 err = -EINVAL; 863 goto restore_opts; 864 } 865 sb->s_flags = (sb->s_flags & ~MS_POSIXACL); 866 867 if ((*flags & MS_RDONLY) && 868 sbi->s_snapshot_cno != old_opts.snapshot_cno) { 869 printk(KERN_WARNING "NILFS (device %s): couldn't " 870 "remount to a different snapshot.\n", 871 sb->s_id); 872 err = -EINVAL; 873 goto restore_opts; 874 } 875 876 if (!nilfs_valid_fs(nilfs)) { 877 printk(KERN_WARNING "NILFS (device %s): couldn't " 878 "remount because the filesystem is in an " 879 "incomplete recovery state.\n", sb->s_id); 880 err = -EINVAL; 881 goto restore_opts; 882 } 883 884 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 885 goto out; 886 if (*flags & MS_RDONLY) { 887 /* Shutting down the segment constructor */ 888 nilfs_detach_segment_constructor(sbi); 889 sb->s_flags |= MS_RDONLY; 890 891 sbi->s_snapshot_cno = nilfs_last_cno(nilfs); 892 /* nilfs_set_opt(sbi, SNAPSHOT); */ 893 894 /* 895 * Remounting a valid RW partition RDONLY, so set 896 * the RDONLY flag and then mark the partition as valid again. 897 */ 898 down_write(&nilfs->ns_sem); 899 sbp = nilfs->ns_sbp[0]; 900 if (!(sbp->s_state & le16_to_cpu(NILFS_VALID_FS)) && 901 (nilfs->ns_mount_state & NILFS_VALID_FS)) 902 sbp->s_state = cpu_to_le16(nilfs->ns_mount_state); 903 sbp->s_mtime = cpu_to_le64(get_seconds()); 904 nilfs_commit_super(sbi, 1); 905 up_write(&nilfs->ns_sem); 906 } else { 907 /* 908 * Mounting a RDONLY partition read-write, so reread and 909 * store the current valid flag. (It may have been changed 910 * by fsck since we originally mounted the partition.) 911 */ 912 if (nilfs->ns_current && nilfs->ns_current != sbi) { 913 printk(KERN_WARNING "NILFS (device %s): couldn't " 914 "remount because an RW-mount exists.\n", 915 sb->s_id); 916 err = -EBUSY; 917 goto restore_opts; 918 } 919 if (sbi->s_snapshot_cno != nilfs_last_cno(nilfs)) { 920 printk(KERN_WARNING "NILFS (device %s): couldn't " 921 "remount because the current RO-mount is not " 922 "the latest one.\n", 923 sb->s_id); 924 err = -EINVAL; 925 goto restore_opts; 926 } 927 sb->s_flags &= ~MS_RDONLY; 928 nilfs_clear_opt(sbi, SNAPSHOT); 929 sbi->s_snapshot_cno = 0; 930 931 err = nilfs_attach_segment_constructor(sbi); 932 if (err) 933 goto restore_opts; 934 935 down_write(&nilfs->ns_sem); 936 nilfs_setup_super(sbi); 937 up_write(&nilfs->ns_sem); 938 939 nilfs->ns_current = sbi; 940 } 941 out: 942 up_write(&nilfs->ns_super_sem); 943 unlock_kernel(); 944 return 0; 945 946 restore_opts: 947 sb->s_flags = old_sb_flags; 948 sbi->s_mount_opt = old_opts.mount_opt; 949 sbi->s_snapshot_cno = old_opts.snapshot_cno; 950 up_write(&nilfs->ns_super_sem); 951 unlock_kernel(); 952 return err; 953 } 954 955 struct nilfs_super_data { 956 struct block_device *bdev; 957 struct nilfs_sb_info *sbi; 958 __u64 cno; 959 int flags; 960 }; 961 962 /** 963 * nilfs_identify - pre-read mount options needed to identify mount instance 964 * @data: mount options 965 * @sd: nilfs_super_data 966 */ 967 static int nilfs_identify(char *data, struct nilfs_super_data *sd) 968 { 969 char *p, *options = data; 970 substring_t args[MAX_OPT_ARGS]; 971 int option, token; 972 int ret = 0; 973 974 do { 975 p = strsep(&options, ","); 976 if (p != NULL && *p) { 977 token = match_token(p, tokens, args); 978 if (token == Opt_snapshot) { 979 if (!(sd->flags & MS_RDONLY)) 980 ret++; 981 else { 982 ret = match_int(&args[0], &option); 983 if (!ret) { 984 if (option > 0) 985 sd->cno = option; 986 else 987 ret++; 988 } 989 } 990 } 991 if (ret) 992 printk(KERN_ERR 993 "NILFS: invalid mount option: %s\n", p); 994 } 995 if (!options) 996 break; 997 BUG_ON(options == data); 998 *(options - 1) = ','; 999 } while (!ret); 1000 return ret; 1001 } 1002 1003 static int nilfs_set_bdev_super(struct super_block *s, void *data) 1004 { 1005 struct nilfs_super_data *sd = data; 1006 1007 s->s_bdev = sd->bdev; 1008 s->s_dev = s->s_bdev->bd_dev; 1009 return 0; 1010 } 1011 1012 static int nilfs_test_bdev_super(struct super_block *s, void *data) 1013 { 1014 struct nilfs_super_data *sd = data; 1015 1016 return sd->sbi && s->s_fs_info == (void *)sd->sbi; 1017 } 1018 1019 static int 1020 nilfs_get_sb(struct file_system_type *fs_type, int flags, 1021 const char *dev_name, void *data, struct vfsmount *mnt) 1022 { 1023 struct nilfs_super_data sd; 1024 struct super_block *s; 1025 struct the_nilfs *nilfs; 1026 int err, need_to_close = 1; 1027 1028 sd.bdev = open_bdev_exclusive(dev_name, flags, fs_type); 1029 if (IS_ERR(sd.bdev)) 1030 return PTR_ERR(sd.bdev); 1031 1032 /* 1033 * To get mount instance using sget() vfs-routine, NILFS needs 1034 * much more information than normal filesystems to identify mount 1035 * instance. For snapshot mounts, not only a mount type (ro-mount 1036 * or rw-mount) but also a checkpoint number is required. 1037 */ 1038 sd.cno = 0; 1039 sd.flags = flags; 1040 if (nilfs_identify((char *)data, &sd)) { 1041 err = -EINVAL; 1042 goto failed; 1043 } 1044 1045 nilfs = find_or_create_nilfs(sd.bdev); 1046 if (!nilfs) { 1047 err = -ENOMEM; 1048 goto failed; 1049 } 1050 1051 mutex_lock(&nilfs->ns_mount_mutex); 1052 1053 if (!sd.cno) { 1054 /* 1055 * Check if an exclusive mount exists or not. 1056 * Snapshot mounts coexist with a current mount 1057 * (i.e. rw-mount or ro-mount), whereas rw-mount and 1058 * ro-mount are mutually exclusive. 1059 */ 1060 down_read(&nilfs->ns_super_sem); 1061 if (nilfs->ns_current && 1062 ((nilfs->ns_current->s_super->s_flags ^ flags) 1063 & MS_RDONLY)) { 1064 up_read(&nilfs->ns_super_sem); 1065 err = -EBUSY; 1066 goto failed_unlock; 1067 } 1068 up_read(&nilfs->ns_super_sem); 1069 } 1070 1071 /* 1072 * Find existing nilfs_sb_info struct 1073 */ 1074 sd.sbi = nilfs_find_sbinfo(nilfs, !(flags & MS_RDONLY), sd.cno); 1075 1076 /* 1077 * Get super block instance holding the nilfs_sb_info struct. 1078 * A new instance is allocated if no existing mount is present or 1079 * existing instance has been unmounted. 1080 */ 1081 s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd); 1082 if (sd.sbi) 1083 nilfs_put_sbinfo(sd.sbi); 1084 1085 if (IS_ERR(s)) { 1086 err = PTR_ERR(s); 1087 goto failed_unlock; 1088 } 1089 1090 if (!s->s_root) { 1091 char b[BDEVNAME_SIZE]; 1092 1093 /* New superblock instance created */ 1094 s->s_flags = flags; 1095 strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id)); 1096 sb_set_blocksize(s, block_size(sd.bdev)); 1097 1098 err = nilfs_fill_super(s, data, flags & MS_VERBOSE, nilfs); 1099 if (err) 1100 goto cancel_new; 1101 1102 s->s_flags |= MS_ACTIVE; 1103 need_to_close = 0; 1104 } 1105 1106 mutex_unlock(&nilfs->ns_mount_mutex); 1107 put_nilfs(nilfs); 1108 if (need_to_close) 1109 close_bdev_exclusive(sd.bdev, flags); 1110 simple_set_mnt(mnt, s); 1111 return 0; 1112 1113 failed_unlock: 1114 mutex_unlock(&nilfs->ns_mount_mutex); 1115 put_nilfs(nilfs); 1116 failed: 1117 close_bdev_exclusive(sd.bdev, flags); 1118 1119 return err; 1120 1121 cancel_new: 1122 /* Abandoning the newly allocated superblock */ 1123 mutex_unlock(&nilfs->ns_mount_mutex); 1124 put_nilfs(nilfs); 1125 deactivate_locked_super(s); 1126 /* 1127 * deactivate_super() invokes close_bdev_exclusive(). 1128 * We must finish all post-cleaning before this call; 1129 * put_nilfs() needs the block device. 1130 */ 1131 return err; 1132 } 1133 1134 struct file_system_type nilfs_fs_type = { 1135 .owner = THIS_MODULE, 1136 .name = "nilfs2", 1137 .get_sb = nilfs_get_sb, 1138 .kill_sb = kill_block_super, 1139 .fs_flags = FS_REQUIRES_DEV, 1140 }; 1141 1142 static int __init init_nilfs_fs(void) 1143 { 1144 int err; 1145 1146 err = nilfs_init_inode_cache(); 1147 if (err) 1148 goto failed; 1149 1150 err = nilfs_init_transaction_cache(); 1151 if (err) 1152 goto failed_inode_cache; 1153 1154 err = nilfs_init_segbuf_cache(); 1155 if (err) 1156 goto failed_transaction_cache; 1157 1158 err = nilfs_btree_path_cache_init(); 1159 if (err) 1160 goto failed_segbuf_cache; 1161 1162 err = register_filesystem(&nilfs_fs_type); 1163 if (err) 1164 goto failed_btree_path_cache; 1165 1166 return 0; 1167 1168 failed_btree_path_cache: 1169 nilfs_btree_path_cache_destroy(); 1170 1171 failed_segbuf_cache: 1172 nilfs_destroy_segbuf_cache(); 1173 1174 failed_transaction_cache: 1175 nilfs_destroy_transaction_cache(); 1176 1177 failed_inode_cache: 1178 nilfs_destroy_inode_cache(); 1179 1180 failed: 1181 return err; 1182 } 1183 1184 static void __exit exit_nilfs_fs(void) 1185 { 1186 nilfs_destroy_segbuf_cache(); 1187 nilfs_destroy_transaction_cache(); 1188 nilfs_destroy_inode_cache(); 1189 nilfs_btree_path_cache_destroy(); 1190 unregister_filesystem(&nilfs_fs_type); 1191 } 1192 1193 module_init(init_nilfs_fs) 1194 module_exit(exit_nilfs_fs) 1195