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